Procedimentos para a

integração de dispositivos ao
sistema de comunicação do
Centro de Medição da
Eletropaulo
Procedimentos para integração de dispositivos de comunicação ao
Sistema de Comunicação do Centro de Medição da Eletropaulo

Objetivo:
Fornecer detalhes do
funcionamento do sistema de
comunicação do Centro de Medição
e os procedimentos realizados
pelos dispositivos a ele conectados.

1
 Procedimentos para integração de dispositivos de comunicação ao
Sistema de Comunicação do Centro de Medição da Eletropaulo

Versão 1.02 de 06/06/2011

Visão geral do sistema:

O sistema de comunicação aqui descrito é fruto da experiência acumulada no

desenvolvimento de atividades relacionadas à teleleitura de medidores eletrônicos na
Eletropaulo. Sua função é fornecer um meio de comunicação transparente para que
aplicações centrais possam enviar e receber informações de elementos espalhados pela
área de concessão. Sua arquitetura foi, inicialmente, concebida para contornar dificuldades
no uso de modems celulares, sendo uma forma de fornecer portas de comunicação TCP-IP
com endereços fixos para equipamentos com endereços dinâmicos. Isso foi possível com a
inserção de um elemento intermediário entre as aplicações centrais e os elementos remotos,
que chamamos de servidor de portas ou gateway.

aplicação  gateway  dispositivo remoto de comunicação  equipamento

A função do gateway é repassar pacotes entre duas de suas portas de comunicação, uma
conhecida pela aplicação central e outra conhecida pelo dispositivo remoto de comunicação,
doravante chamado apenas de dispositivo. Ambos os lados tomam a iniciativa de conexão à
respectiva porta, porém, o dispositivo deve tentar manter-se permanentemente conectado,
de modo que a aplicação possa acessá-lo a qualquer momento. Esta estratégia permite que
aplicação desconheça o endereço real do dispositivo.

O uso do gateway pode adicionar outros benefícios a um sistema de comunicação:

 A uniformização no uso de diversos tipos de mídias.
 O gerenciamento e o monitoramento do uso dos recursos de comunicação.
 A priorização de canais para aplicações críticas.
 Melhoria na segurança através da aplicação de algoritmos de criptografia e ao
isolamento que proporciona.

O dispositivo deve prover toda a automação necessária para executar o procedimento de

conexão ao gateway. Além disso, ele também é responsável pelas seguintes tarefas:
 Receber pacotes do gateway, descriptografá-los e repassá-los ao equipamento nele
conectado.
 Receber pacotes do equipamento, criptografá-los e repassá-los ao gateway.
 Manter a conexão com o gateway, enviando periodicamente, se necessário,
pequenos pacotes conhecidos como mensagens de keep-alive em intervalos de
tempo configuráveis.
 Reconectar-se toda vez que houver quebra de conexão

Procedimento para conexão:

A conexão se dá em duas etapas:

Na primeira etapa os dispositivos se conectam a uma porta do gateway chamada de porta

default, única para todos os dispositivos. Depois de autenticados nessa porta eles recebem
um novo endereço IP e uma nova porta, chamada de porta definitiva.

Na segunda etapa eles se conectam na porta definitiva, devendo permanecer trocando

dados até que haja uma quebra de conexão.

No processo de conexão, os dispositivos são identificados através de três cadeias de

caracteres:
 Número de identificação do dispositivo no cadastro do gateway, conhecido como ID,
com tamanho de 16 caracteres ASCII, configurado no dispositivo.
 Número de série do equipamento com 15 caracteres ASCII. No caso de modems
celulares é o número conhecido como ESN (Eletronic Serial Number).

2
 Procedimentos para integração de dispositivos de comunicação ao
Sistema de Comunicação do Centro de Medição da Eletropaulo
 Número de série do SIMCARD com 15 caracteres ASCII, ou 15 caracteres ‘0’ se não
se aplicar.

Detalhamento da primeira etapa de conexão:

1. O gateway aguarda conexões na porta default.
2. O dispositivo se conecta ao gateway na porta default.
3. O gateway envia imediatamente um pacote não criptografado com 32 bytes de
tamanho, contendo a chave de criptografia nos primeiros 16 bytes e um id,
conhecido como id do data linker, nos outros 16 bytes. Existem chaves específicas
para trabalhar sem criptografia ou para indicar ao dispositivo que ele deve usar a
chave anterior. O gateway aguardará por 20 segundos a resposta do dispositivo,
decorrido este tempo a conexão será finalizada pelo gateway.
4. O dispositivo deve responder enviando um pacote criptografado, com 48 bytes de
carga útil, contendo as cadeias de identificação mencionadas anteriormente, no
seguinte formato:
a. O id do dispositivo com 16 caracteres ASCII.
b. O caractere ‘-‘ como separador de campos.
c. O número de série do equipamento com 15 caracteres ASCII.
d. Outro caractere ‘-‘.
e. O número de série do SIMCARD com 15 caracteres ASCII.
5. O gateway fechará imediatamente a conexão se o dispositivo não estiver autorizado
ou a mensagem contiver erros, caso contrário, ele responderá imediatamente um
pacote criptografado, com 6 bytes de carga útil, contendo:
a. Nos 2 primeiros bytes o número da porta definitiva como um inteiro não
sinalizado de 2 bytes de tamanho na notação big-endian [MSB,LSB].
b. Nos outros 4 bytes restantes, o endereço IP definitivo na notação Network
Byte Order (um inteiro não sinalizado de 4 bytes de tamanho com o LSB
primeiro).
6. Ao receber o pacote, o dispositivo deve fechar imediatamente a conexão. O gateway
aguardará o fechamento por 20 segundos, caso contrário, ele mesmo o fará.

Detalhamento da segunda etapa de conexão:

1. O gateway aguarda conexão na porta definitiva.
2. O dispositivo se conecta ao gateway na porta definitiva.
3. Idem ao item 3 da primeira etapa.
4. Idem ao item 4 da primeira etapa.
5. O gateway fechará imediatamente a conexão se o dispositivo não estiver autorizado
ou a mensagem contiver erros, caso contrário, ele aceitará a conexão e o dispositivo
deve preparar-se para trafegar dados. Simultaneamente, o gateway começará a
aguardar conexões na porta destinada às aplicações.

Operação após a conexão:

Depois que a conexão foi estabelecida, os pacotes enviados pela aplicação serão
criptografados pelo gateway e repassados ao dispositivo, que por sua vez, ao recebê-los,
fará a descriptografia e os repassará ao equipamento a ele conectado. Os pacotes enviados
pelo equipamento serão criptografados pelo dispositivo e repassados ao gateway, que por
sua vez, fará a descriptografia e os repassará à aplicação.

Caso a conexão fique ociosa por um tempo maior que o configurado no dispositivo, este
deverá enviar um pacote de 10 bytes, não criptografado, com o texto “KEEP ALIVE”. Não há
resposta do gateway para mensagens de keep-alive.

Caso o gateway fique sem receber mensagens de keep-alive por um tempo maior que duas
vezes o tempo estabelecido, ele mesmo quebrará a conexão.

3
 Procedimentos para integração de dispositivos de comunicação ao
Sistema de Comunicação do Centro de Medição da Eletropaulo
Se ocorrer quebra da conexão, não importando o motivo, o dispositivo deve tentar
reconectar-se imediatamente.

Diagramas:
Equipamento Dispositivo Gateway Aplicação
Conecta na porta 
default
 Envia chave +
id_data_linker
Envia msg 
criptografada com a
identificação
 Envia msg
criptografada com a
porta definitiva +
novo IP
Desconecta da
porta default
----------- --- --------------- --- --------------- --- ---------
Conecta na porta 
definitiva
 Envia chave +
id_data_linker
Envia msg 
criptografada com a
identificação
----------- --- --------------- --- --------------- --- ---------
 Envia pacote
 Envia pacote
criptografado
 Recebe,
descriptografa e
repassa pacote
Envia pacote 
Envia pacote 
criptografado
Recebe, 
descriptografa e
repassa pacote
----------- --- --------------- --- --------------- --- ---------
Se tempo de 
inatividade excedeu
tempo configurado,
envia mensagem de
keep-alive

4
 Procedimentos para integração de dispositivos de comunicação ao
Sistema de Comunicação do Centro de Medição da Eletropaulo

Descrição da criptografia:
O algoritmo de criptografia usado é o XTEA ('Extended' Tiny Encryption Algorithm), que é
aplicado sobre blocos com 8 bytes de tamanho, deste modo, os pacotes deverão ter seus
tamanhos ajustados para valores múltiplos de 8 bytes.

O tamanho do pacote original é informado nos 2 primeiros bytes de cada mensagem

criptografa na notação big-endian [MSB+LSB].

Mensagens não criptografadas não são precedidas do tamanho, portanto, são transmitidas
em seu tamanho original.

As chaves de criptografia citadas abaixo indicam que deverá ser usada a chave anterior:
 "FFFFFFFFFFFFFFFF" (16 bytes com o caractere "F" em ASCII)
 FF.FF.FF.FF.FF.FF.FF.FF.FF.FF.FF.FF.FF.FF.FF.FF (16 bytes com valor 0xFF)

As chaves de criptografia citadas abaixo indicam que a criptografia deverá ser desativada:
 "0000000000000000" (16 bytes com "0" em ASCII)
 00.00.00.00.00.00.00.00.00.00.00.00.00.00.00.00 (16 bytes com valor 0x00)

O tamanho máximo do bloco de dados deve ser de 520 bytes.

Procedimento para criptografar um pacote:

 Preparar um buffer com tamanho múltiplo de 8 bytes e limitado a 520 bytes.
 Colocar nos 2 primeiros bytes o tamanho do pacote original [MSB+LSB].
 Adicionar em seguida os bytes do pacote original.
 Aplicar o algoritmo de criptografia sobre o buffer.

Procedimento para descriptografar um pacote:

 Buffer recebido deve ter tamanho múltiplo de 8 bytes;
 Aplicar o algoritmo de descriptografia sobre este buffer;
 Pegar o tamanho do pacote original nos 2 primeiros bytes.
 Pegar o pacote original nos bytes seguintes.

5
 Procedimentos para integração de dispositivos de comunicação ao
Sistema de Comunicação do Centro de Medição da Eletropaulo

Algoritmo de criptografia implementado em JavaScript:

<html>
<head>
<title>JavaScript Implementation of Extended TEA Tiny Encryption Algorithm
(© 2000 Chris Veness)</title>
<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
<meta name="author" content="Chris Veness, 2001">
<style type="text/css"> <!-- p, td { font-family: Arial, sans-serif; } --> </style>
<script type="text/javascript">

//
// 'Extended' Tiny Encryption Algorithm
//
// Algorithm: David Wheeler & Roger Needham, Cambridge University Computer Lab
// http://www.cl.cam.ac.uk/ftp/papers/djw-rmn/djw-rmn-tea.html (1994)
// http://www.cl.cam.ac.uk/ftp/users/djw3/xtea.ps (1997)
//
// JavaScript implementation: Chris Veness, Movable Type Ltd: www.movable-type.co.uk
//

function encrypt(val, key)

{
// 128 bits (16 chars) of string 'key' are used to encrypt string 'val'; function
// returns encrypted version of 'val'.
var v = new Array(2), k = new Array(4), s = "", i;

val = escape(val); // use escape() so only have single-byte chars to encode

k[0] = Str4ToLong(key.substr(0,4));
k[1] = Str4ToLong(key.substr(4,4));
k[2] = Str4ToLong(key.substr(8,4));
k[3] = Str4ToLong(key.substr(12,4));

for (i=0; i<val.length; i+=8) { // encode val into s in 64-bit (8 char) blocks
v[0] = Str4ToLong(val.substr(i,4));
v[1] = Str4ToLong(val.substr(i+4,4));
code(v, k);
s += LongToStr4(v[0]) + LongToStr4(v[1]);
}

return(s)
// note: if val or key are passed as string objects, rather than strings, this
// function will throw an 'Object doesn't support this property or method' error
}

6
 Procedimentos para integração de dispositivos de comunicação ao
Sistema de Comunicação do Centro de Medição da Eletropaulo
function decrypt(val, key)
{
var v = new Array(2), k = new Array(4), s = "", i;

k[0] = Str4ToLong(key.substr(0,4));
k[1] = Str4ToLong(key.substr(4,4));
k[2] = Str4ToLong(key.substr(8,4));
k[3] = Str4ToLong(key.substr(12,4));

for (i=0; i<val.length; i+=8) { // decode val into s in 64-bit (8 char) blocks
v[0] = Str4ToLong(val.substr(i,4));
v[1] = Str4ToLong(val.substr(i+4,4));
decode(v, k);
s += LongToStr4(v[0]) + LongToStr4(v[1]);
}

if (s.indexOf("\x00") != -1) {
// strip trailing null chars resulting from filling 4-char blocks
s = s.substr(0, s.indexOf("\x00"));
}

return(unescape(s));
}

function code(v, k)
{
// Extended TEA: this is the 1997 revised version of Needham & Wheeler's algorithm
// params: v[2] 64-bit value block; k[4] 128-bit key
var y = v[0], z = v[1];
var delta = 0x9E3779B9, limit = delta*32, sum = 0;

while (sum != limit) {

y += (z<<4 ^ z>>>5)+z ^ sum+k[sum & 3];
sum += delta;
z += (y<<4 ^ y>>>5)+y ^ sum+k[sum>>>11 & 3];
// note: unsigned right-shift '>>>' is used in place of original '>>', due to lack
// of 'unsigned' type declaration in JavaScript (thanks to Karsten Kraus for this)
}
v[0] = y; v[1] = z;
}

function decode(v, k)
{
var y = v[0], z = v[1];
var delta = 0x9E3779B9, sum = delta*32;

while (sum != 0) {
z -= (y<<4 ^ y>>>5)+y ^ sum+k[sum>>>11 & 3];
sum -= delta;
y -= (z<<4 ^ z>>>5)+z ^ sum+k[sum & 3];
}
v[0] = y; v[1] = z;
}

7
 Procedimentos para integração de dispositivos de comunicação ao
Sistema de Comunicação do Centro de Medição da Eletropaulo
function Str4ToLong(s) // convert 4 chars of s to a numeric long
{
var v = s.charCodeAt(0) +
(s.charCodeAt(1)<<8) +
(s.charCodeAt(2)<<16) +
(s.charCodeAt(3)<<24);
return(isNaN(v) ? 0 : v);
}

function LongToStr4(v) // convert a numeric long to 4 char string

{
var s = String.fromCharCode(v & 0xFF, v>>8 & 0xFF, v>>16 & 0xFF, v>>24 & 0xFF);
return(s);
}

</script>
</head>

<body>
<p><b>TEA (Tiny Encryption Algorithm)</b></p>

<p>128 bits (16 characters) from the Key will be used to encrypt the Value, using
Wheeler & Needham&rsquo;s
<a href="http://www.ftp.cl.cam.ac.uk/ftp/papers/djw-rmn/djw-rmn-tea.html">Tiny
Encryption Algorithm</a>.</p>
<p>This can be useful for instance to encrypt passwords which shouldn&rsquo;t
be stored in clear.</p>
<p>The more recent <a href="TEAblock.html"><b>Block TEA</b></a> is simpler and
more
effective, especially for arbitrary-length strings.</p>
<form name="f" action="none!">
<table>
<tr>
<td>Key:</td>
<td><input type="text" name="key" size="16" value="encryption-key"></td>
</tr>
<tr>
<td>Value:</td>
<td><input type="text" name="val" size="60"
value="some text to be encrypted such as a password"></td>
</tr>
<tr>
<td><script type="text/javascript">var ciferText;</script>
<!-- use 'ciferText' because <input> field will truncate at null chars -->
<input type="button" value="Encrypt it"
onClick='f.encrypted.value = ciferText = encrypt(f.val.value, f.key.value)'></td>
</tr>
<tr>
<td>Encrypted value:</td>
<td><input type="text" name="encrypted" size="60"></td>
</tr>
<tr>
<td><input type="button" value="Decrypt it"
onClick='f.decrypted.value = decrypt(ciferText, f.key.value)'></td>
</tr>

8
 Procedimentos para integração de dispositivos de comunicação ao
Sistema de Comunicação do Centro de Medição da Eletropaulo
<tr>
<td>Value back in clear:</td>
<td><input type="text" name="decrypted" size="60"></td>
</tr>
</table>
</form>
<p>Use &lsquo;View Source&rsquo; to see the JavaScript implementation.</p>
<p><ahref="http://www.movable-type.co.uk">&#x25C4;www.movable-
pe.co.uk</a></p>
</body>

</html>

9
 Procedimentos para integração de dispositivos de comunicação ao
Sistema de Comunicação do Centro de Medição da Eletropaulo

Algoritmo de criptografia implementado em C++:

/*---------------------------------------------------------
Nome: xtea.h
---------------------------------------------------------
Descrição:

'Extended' Tiny Encryption Algorithm

Algorithm: David Wheeler & Roger Needham, Cambridge University

Computer Lab
http://www.cl.cam.ac.uk/ftp/papers/djw-rmn/djw-rmn-tea.html (1994)
http://www.cl.cam.ac.uk/ftp/users/djw3/xtea.ps (1997)

JavaScript implementation: Chris Veness, Movable Type Ltd:

www.movable-type.co.uk
C implementation: Ricardo Yukio Hayashi - Atech - 30/11/2004
C++ implementation: Ronaldo David Cavaquini - Eletropaulo -
10/11/2010
---------------------------------------------------------*/

#ifndef __XTEA_H__
#define __XTEA_H__

namespace XTEA
{
void encrypt( char* val, int size, char* key );
void decrypt( char* val, int size, char* key );
}

#endif

10
 Procedimentos para integração de dispositivos de comunicação ao
Sistema de Comunicação do Centro de Medição da Eletropaulo
/*---------------------------------------------------------
Nome: xtea.cpp
---------------------------------------------------------
Descrição:

'Extended' Tiny Encryption Algorithm

Algorithm: David Wheeler & Roger Needham, Cambridge University

Computer Lab
http://www.cl.cam.ac.uk/ftp/papers/djw-rmn/djw-rmn-tea.html (1994)
http://www.cl.cam.ac.uk/ftp/users/djw3/xtea.ps (1997)

JavaScript implementation:
Chris Veness, Movable Type Ltd: www.movable-type.co.uk

C/C++ implementation:
Ricardo Yukio Hayashi - Atech - 30/11/2004
Ronaldo David Cavaquini - Eletropaulo - 05/10/2005
---------------------------------------------------------*/

#include <string.h>
#include <xtea.h>
#include <stdio.h>

// Different multiples of a magic constant are used to prevent

// simple attacks based on the symmetry of the rounds.
// The magic constant is chosen to be 2^32/ goldenRatio.
// GoldenRadio:
// 1 a
// ------ = -------
// a 1 - a
//
// 1 - a = a^2
//
// a^2 + a -1 = 0
//
// 1 +/- 5^(1/2)
// a = ---------------
// 2
//
// golden ratio = 1/a = 2/((5^(1/2))-1) ~= 1.6180339887
//
// DELTA = (2^32)/(2/((5^(1/2))-1))=0x9E3779B9

static const unsigned int DELTA = 0x9E3779B9;

// recommended 64 Feistel rounds (32 cycles )

static const unsigned int NUM_CYCLES = 32;

11
 Procedimentos para integração de dispositivos de comunicação ao
Sistema de Comunicação do Centro de Medição da Eletropaulo
/*---------------------------------------------------------
Extended TEA: this is the 1997 revised version of
Needham & Wheeler's algorithm
---------------------------------------------------------
Parameters:
v[2] = 64-bit value block
k[4] = 128-bit KEY
---------------------------------------------------------
Return: Nothing
---------------------------------------------------------*/
static void code( unsigned int* v, unsigned int* k )
{
unsigned int y = v[0];
unsigned int z = v[1];
unsigned int sum = 0;

for( int i = 0; i < NUM_CYCLES; i++ )

{
y += ((z<<4 )^(z>>5))+(z^sum)+k[sum&3];
sum += DELTA;
z += ((y<<4)^(y>>5))+(y^sum)+k[sum>>11&3];
}
v[0] = y;
v[1] = z;
}

/*---------------------------------------------------------
Extended TEA: this is the 1997 revised version of
Needham & Wheeler's algorithm
---------------------------------------------------------
Parameters:
v[2] = 64-bit value block
k[4] = 128-bit KEY
---------------------------------------------------------
Return: Nothing
---------------------------------------------------------*/
static void decode( unsigned int* v, unsigned int* k )
{
unsigned int y = v[0];
unsigned int z = v[1];

#pragma warning ( disable: 4307 )

unsigned int sum = DELTA * NUM_CYCLES;
#pragma warning ( default: 4307 )

for( int i = 0; i < NUM_CYCLES; i++ )

{
z -= ((y<<4)^(y>>5)) + (y^sum)+k[sum>>11&3];
sum -= DELTA;
y -= ((z<<4 )^(z>>5))+(z^sum)+k[sum&3];
}
v[0] = y;
v[1] = z;
}

/*---------------------------------------------------------
Convert 4 chars of s to a numeric long
---------------------------------------------------------
Parameters:
s = array of chars
---------------------------------------------------------

12
 Procedimentos para integração de dispositivos de comunicação ao
Sistema de Comunicação do Centro de Medição da Eletropaulo
Return:
Resultant value
---------------------------------------------------------*/
static unsigned int Str4ToLong( char* s )
{
unsigned int d = (unsigned char) s[3];
d <<= 8;
d += (unsigned char) s[2];
d <<= 8;
d += (unsigned char) s[1];
d <<= 8;
d += (unsigned char) s[0];
return d;
}

/*---------------------------------------------------------
Convert a numeric long to 4 char string
---------------------------------------------------------
Parameters:
v = long to convert
s = destinaion array of chars
---------------------------------------------------------
Return: Nothing
---------------------------------------------------------*/
static void LongToStr4( unsigned int v, char* s )
{
s[0] = v & 0xFF;
s[1] = v >> 8 & 0xFF;
s[2] = v >> 16 & 0xFF;
s[3] = v >> 24 & 0xFF;
}

/*---------------------------------------------------------
128 bits (16 chars) of string 'key' are used to encrypt
string 'val'
---------------------------------------------------------
Parameters:
val = ptr to the buffer
size = lenght of the buffer
key = 128 bit key
---------------------------------------------------------
Return: Nothing
---------------------------------------------------------*/
void XTEA::encrypt( char* val, int size, char* key )
{
unsigned int v[2];
unsigned int k[4];
char s[5];

k[0] = Str4ToLong( &key[0] );

k[1] = Str4ToLong( &key[4] );
k[2] = Str4ToLong( &key[8] );
k[3] = Str4ToLong( &key[12] );

// encode val into s in 64-bit (8 char) blocks

for( int i = 0; i < size; i += 8 )
{
v[0] = Str4ToLong( &val[i] );
v[1] = Str4ToLong( &val[i+4] );

13
 Procedimentos para integração de dispositivos de comunicação ao
Sistema de Comunicação do Centro de Medição da Eletropaulo
code( v, k );

LongToStr4( v[0], s );
memmove( &val[i], s, 4 );
LongToStr4( v[1], s );
memmove( &val[i+4], s, 4 );
}
}

/*---------------------------------------------------------
Use the 128 bit key to decrypt the string v
---------------------------------------------------------
Parameters:
val = ptr to the buffer
size = lenght of the buffer
key = 128 bit key
---------------------------------------------------------
Return: Nothing
---------------------------------------------------------*/
void XTEA::decrypt( char* val, int size, char* key )
{
unsigned int v[2];
unsigned int k[4];
char s[5];

k[0] = Str4ToLong( &key[0] );

k[1] = Str4ToLong( &key[4] );
k[2] = Str4ToLong( &key[8] );
k[3] = Str4ToLong( &key[12] );

// encode val into s in 64-bit ( 8 char ) blocks

for( unsigned short i = 0; i < size; i += 8 )
{
v[0] = Str4ToLong( &val[i] );
v[1] = Str4ToLong( &val[i+4] );
decode( v, k );
LongToStr4( v[0], s );
memmove( &val[i], s, 4 );
LongToStr4( v[1], s );
memmove( &val[ i + 4 ], s, 4 );
}
}

14
 Procedimentos para integração de dispositivos de comunicação ao
Sistema de Comunicação do Centro de Medição da Eletropaulo

Exemplo de mensagens para conexão de dispositivo com ID = 2593.

Obs: Valores em hexadecimal.

Mensagem recebida com a chave de criptografia:

RECV:
31 32 31 32 31 32 32 30 30 37 31 32 32 31 30 30
30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 31

Mensagem de identificação antes da criptografia:

SEND:
00 30 30 30 30 30 30 30 30 30 30 30 30 30 32 35
39 33 2D 30 31 32 33 34 35 36 37 38 39 30 31 32
33 34 2D 30 30 30 30 30 30 30 30 30 30 30 30 30
30 30 61 31 54 78 B8 3F

Mensagem de identificação depois de criptografada:

SEND:
72 D2 1F A8 77 9E C8 C0 C6 2A 15 5F D1 3E CC 17
6E 40 29 D6 71 A2 47 8B 69 A1 AE CB EA 4C 77 82
F7 DE 15 82 5D 63 19 D1 BE A7 4F 2F B5 7B C1 84
43 68 3F E0 EA 69 A5 84

Resposta criptografada do gateway com o endereço IP e porta

definitivos:
RECV:
A2 36 3A 30 A7 C0 8E 05

Resposta do gateway com o endereço IP e porta definitivos, depois de

descriptografada:
RECV:
00 06 CD 71 0A FB 1C 8A

Mensagem recebida com a chave de criptografia na conexão na porta

definitiva:
RECV:
31 32 31 32 31 32 32 30 30 37 31 32 32 31 30 30
30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 31

Mensagem de identificação antes da criptografia:

SEND:
00 30 30 30 30 30 30 30 30 30 30 30 30 30 32 35
39 33 2D 30 31 32 33 34 35 36 37 38 39 30 31 32
33 34 2D 30 30 30 30 30 30 30 30 30 30 30 30 30
30 30 3F E0 EA 69 A5 84

Mensagem de identificação depois de criptografada:

SEND:
72 D2 1F A8 77 9E C8 C0 C6 2A 15 5F D1 3E CC 17
6E 40 29 D6 71 A2 47 8B 69 A1 AE CB EA 4C 77 82
F7 DE 15 82 5D 63 19 D1 BE A7 4F 2F B5 7B C1 84
E8 F6 99 DC 8B CE 1E 1D

Conectado

Mensagem de keep-alive:
SEND
4B 45 45 50 20 41 4C 49 56 45

15