Reguli de codificare de bază

Basic Encoding Rules (abrevierea BER ) este un sistem de codificare compus dintr-un set de reguli pentru conversia datelor eterogene în fluxuri de octeți .

Codificarea BER este strâns legată de standardul ASN.1 și este utilizată pentru comunicațiileSNMP și LDAP .

Sistem de codare

Sistemul de codare se bazează pe conceptul de triplu <T, L, V> (tip sau etichetă, lungime, valoare) unde:

Tipul sau eticheta : indică tipul datelor codificate
Lungime : indică lungimea în octeți a „Valoare”
Valoare : sunt datele codificate efectiv

De exemplu, pentru a codifica datele 7 ca ÎNTREGERE va dura 3 octeți:

primul care indică tipul (INTEGER = 02₁₆);
al doilea indicând Lungimea lui v (în acest caz = 01₁₆).
al treilea este codificarea ÎNTREGUTELOR date în conformitate cu regulile BER (în acest caz 07₁₆);

În cele din urmă, INTEGER 7 în BER devine 020107₁₆, unde T, L și V se disting clar.

BER și ASN.1

BER este strâns legat de ASN.1, în special în ceea ce privește tipurile de date. După cum vă puteți imagina, codificarea lui V depinde de tipul T. Există unele tipuri predefinite în ASN.1 (se spune că sunt etichete aparținând clasei UNIVERSAL ). Pentru mai multe informații despre aceasta, consultați [1] .

Codificare BER

În general, când trebuie efectuată codificarea BER a unei date, procedați după cum urmează:

este codificat T;
este codificat V;
de la lungimea lui V trecem la codificarea lui L.

Să vedem acum codarea fiecărui câmp.

Codificarea T

Codificarea câmpului T necesită de obicei un singur octet. Codificarea depinde de următorii factori:

Clasa căreia îi aparține eticheta
Tipul este PRIMITIV sau CONSTRUIT
Identificatorul etichetei din clasa căreia îi aparține

Dacă identificatorul tipului $0<=ID<=30$ ${\ displaystyle 0 <= ID <= 30}$ ${\ displaystyle 0 <= ID <= 30}$ atunci codificarea lui T necesită un singur octet, altfel numărul de octeți al lui T va depinde de valoarea ID-ului

Primul octet al lui T

Să vedem mai jos cum arată primul octet al lui T :

Primul octet al lui T

Codificarea CLASS urmează următorul tabel:

 bit 7 bit 6 CLASA
 -----------------------------------
   0 0 UNIVERSAL
   0 1 CERERE
   1 0 specific contextului
   1 1 PRIVAT

Bitul P \ C = 0 indică faptul că tipul este PRIMITIV (adică este un tip simplu, cum ar fi INTEGER sau OID)

Bitul P \ C = 1 indică faptul că tipul este CONSTRUIT (adică este un tip compus din mai multe tipuri simple, cum ar fi SECVENȚĂ)

În schimb, cei 5 biți de TAG :

Acestea conțin valoarea binară a ID-ului dacă $0<=ID<=30$ ${\ displaystyle 0 <= ID <= 30}$ ${\ displaystyle 0 <= ID <= 30}$
Acestea conțin $11111_{2}$ ${\ displaystyle 11111_ {2}}$ ${\ displaystyle 11111_ {2}}$ de sine $ID>30$ ${\ displaystyle ID> 30}$ ${\ displaystyle ID> 30}$

În primul caz, așa cum sa spus deja, T este alcătuit dintr-un singur octet. În al doilea caz, ceilalți octeți de T trebuie codați.

Alți octeți de T

Pentru a codifica ceilalți octeți procedați după cum urmează:

convertiți ID - ul în binar
un 1 este adăugat la fiecare 7 biți
octetul este completat cu un 0 principal

NB !!! doar corectat !!! ultimul octet care alcătuiește ID-ul este compus cu un '0' în cap, doar pentru a indica faptul că ID-ul se termină cu acel octet.

Alți octeți de T

De exemplu. dacă ID = 250 în baza 10, atunci:

$250_{10}=FA_{16}=11111010_{2}$ ${\ displaystyle 250_ {10} = FA_ {16} = 11111010_ {2}}$ ${\ displaystyle 250_ {10} = FA_ {16} = 11111010_ {2}}$
11111010 -> 1 1 1111010
1 1 1111010 -> 1 0000001 0 1111010

În cele din urmă ID = 250 este codificat cu $81FA_{16}$ ${\ displaystyle 81FA_ {16}}$ ${\ displaystyle 81FA_ {16}}$

Exemplul 1 de codificare a lui T

Codificare INTEGER. Aceasta este clasa UNIVERSALĂ și este PRIMITIV. ID-ul său în clasa UNIVERSAL este 2.

ID<=30

{\ displaystyle ID <= 30}

{\ displaystyle ID <= 30}

și, prin urmare, doar 1 octet va fi suficient pentru T

Prin urmare:

CLASA = 00

P \ C = 0

Etichetă = 00010

din care rezultă:

T=02_{16}

{\ displaystyle T = 02_ {16}}

{\ displaystyle T = 02_ {16}}

Exemplul 2 de codificare a lui T

Să presupunem că vrem să codăm un tip PRIVAT și PRIMITIV cu $ID=250_{10}$ ${\ displaystyle ID = 250_ {10}}$ ${\ displaystyle ID = 250_ {10}}$

ID>30

{\ displaystyle ID> 30}

{\ displaystyle ID> 30}

și, prin urmare, vor fi necesari mai mulți octeți pentru T

Primul octet:

CLASA = 11

P \ C = 0

Etichetă = 11111 ->

primobyte=11011111_{2}=DF_{16}

{\ displaystyle primobyte = 11011111_ {2} = DF_ {16}}

{\ displaystyle primobyte = 11011111_ {2} = DF_ {16}}

Alți octeți (așa cum am văzut mai devreme) sunt egali cu $81FA_{16}$ ${\ displaystyle 81FA_ {16}}$ ${\ displaystyle 81FA_ {16}}$ deoarece $ID=250_{10}$ ${\ displaystyle ID = 250_ {10}}$ ${\ displaystyle ID = 250_ {10}}$

În cele din urmă, în acest caz $T=DF81FA_{16}$ ${\ displaystyle T = DF81FA_ {16}}$ ${\ displaystyle T = DF81FA_ {16}}$ și este de 3 octeți .

Codificarea L

În această secțiune, Len (V) indică numărul de octeți de V.

Codificarea lui L este strict legată de lungimea datelor codificate V. Dacă Len (V) este cunoscut aprioric, continuați cu codificarea lungimii definite , altfel se aplică codificarea lungimii nedeterminate . Prima tehnică este de preferat, deoarece permite o decodificare mai simplă.

Codificarea L „lungimea definită”

În acest tip de codificare există 2 cazuri distincte:

de sine $Len(V)<127$ ${\ displaystyle Len (V) <127}$ ${\ displaystyle Len (V) <127}$ atunci L este codificat în 1 octet ( formă definită scurt )
de sine $Len(V)>=127$ ${\ displaystyle Len (V)> = 127}$ ${\ displaystyle Len (V)> = 127}$ atunci L este codificat în mai mulți octeți ( formă definită lung )

Cazul 1: L în 1 octet - formă definită scurt

Acesta este cel mai simplu caz. V este codificat în mai puțin de 127 de octeți și L conține doar valoarea lui Len (V) în hexazecimal.

Limita de 127 octeți este dată de faptul că 127 este 7F în hexazecimal (01111111 în binar) și, prin urmare, primul bit al lui L este cu siguranță zero.

Acest lucru este util în faza de decodare, de fapt, dacă primul bit este zero, înseamnă că codarea lui L a fost utilizată pe un singur octet.

L în formă scurtă

Cazul 2: L în mai mulți octeți - formă definitivă lungă

În acest caz, procedați după cum urmează:

cod binar Len (V)
se calculează $Len(Len(V))$ ${\ displaystyle Len (Len (V))}$ ${\ displaystyle Len (Len (V))}$ , adică lungimea în octeți a lui Len (V)
este plasat în primul octet al lui L = $Len(Len(V))+80_{16}$ ${\ displaystyle Len (Len (V)) + 80_ {16}}$ ${\ displaystyle Len (Len (V)) + 80_ {16}}$
este plasat în următorii octeți Len (V)

Formula punctului 3 are următoarea justificare:

adăugând $80_{16}$ ${\ displaystyle 80_ {16}}$ ${\ displaystyle 80_ {16}}$ ultimul bit al primului octet al lui L este obligat să fie 1.
în primii 7 biți ai primului octet de L există de fapt lungimea restului de octeți de L , de fapt $Len(Len(V))+1$ ${\ displaystyle Len (Len (V)) + 1}$ ${\ displaystyle Len (Len (V)) + 1}$ indică lungimea lui L

L într-o formă lung definită

În faza de decodare pentru a înțelege că folosim o codificare L pe mai mulți octeți de tip definit de lungă durată trebuie să fie:

primul bit al primului octet al lui L = 1
ceilalți 7 biți ai primului octet trebuie să fie diferiți de $0000000_{2}$ ${\ displaystyle 0000000_ {2}}$ ${\ displaystyle 0000000_ {2}}$

Exemplul 1 de codificare a lui L într- o formă definită

V este codificat pe 120 de octeți.

Atâta timp cât $120<127$ ${\ displaystyle 120 <127}$ ${\ displaystyle 120 <127}$ de aceea trebuie folosită forma scurtă definită

Categoric:

L=78_{16}

{\ displaystyle L = 78_ {16}}

{\ displaystyle L = 78_ {16}}

Exemplul 2 de codificare a lui L într- o formă definită

V este codificat peste 1000 de octeți.

Atâta timp cât $1000_{10}>127_{10}$ ${\ displaystyle 1000_ {10}> 127_ {10}}$ ${\ displaystyle 1000_ {10}> 127_ {10}}$ de aceea trebuie folosită forma lungă definită .

Prin urmare:

$Len(V)=1000_{10}=3E8_{16}=03E8_{16}$ ${\ displaystyle Len (V) = 1000_ {10} = 3E8_ {16} = 03E8_ {16}}$ ${\ displaystyle Len (V) = 1000_ {10} = 3E8_ {16} = 03E8_ {16}}$
$Len(Len(V))=2_{10}=02_{16}$ ${\ displaystyle Len (Len (V)) = 2_ {10} = 02_ {16}}$ ${\ displaystyle Len (Len (V)) = 2_ {10} = 02_ {16}}$
octetul 1 din L $=Len(Len(V))+80_{16}=82_{16}=10000010_{2}$ ${\ displaystyle = Len (Len (V)) + 80_ {16} = 82_ {16} = 10000010_ {2}}$ ${\ displaystyle = Len (Len (V)) + 80_ {16} = 82_ {16} = 10000010_ {2}}$
octeți 2,3 din L $=Len(V)=03E8_{16}$ ${\ displaystyle = Len (V) = 03E8_ {16}}$ ${\ displaystyle = Len (V) = 03E8_ {16}}$

Categoric: $L=8203E8_{16}$ ${\ displaystyle L = 8203E8_ {16}}$ ${\ displaystyle L = 8203E8_ {16}}$ și este de $Len(Len(V))+1=2+1=3bytes$ ${\ displaystyle Len (Len (V)) + 1 = 2 + 1 = 3bytes}$ ${\ displaystyle Len (Len (V)) + 1 = 2 + 1 = 3bytes}$

Codificarea „lungimii nedeterminate”

Acest tip de codificare ti este utilizat atunci când Len (a) a priori nu este cunoscut.

În acest caz, continuați cu următorii pași:

apare $L=10000000_{2}=80_{16}$ ${\ displaystyle L = 10000000_ {2} = 80_ {16}}$ ${\ displaystyle L = 10000000_ {2} = 80_ {16}}$
Se adaugă V
2 octeți de zerouri sunt adăugați la coada V $0000_{16}$ ${\ displaystyle 0000_ {16}}$ ${\ displaystyle 0000_ {16}}$

Codare V

Codificarea lui V , așa cum s-a spus de mai multe ori, depinde de tipul T și de definiția acestuia prin sintaxa ASN.1 Aici vom ilustra codificarea celor 3 tipuri principale: INTEGER, OCTECT STRING și OBJECT ID. Pentru o imagine de ansamblu completă a decodificării codării, vă rugăm să consultați din nou la [2] sau [3]

Codificare INTEGER

Codificarea unui INTEGER dat depinde de semnul acestuia. Primul bit al primului octet codat se numește bitul de semn . Dacă acesta este 0, atunci numărul este pozitiv, altfel este negativ.

INTEGER pozitiv

În acest caz, codificarea este dată de valoarea binară a numărului, atâta timp cât bitul de semn este respectat, altfel un octet de zerouri trebuie adăugat la cap

De fapt, dacă întregul este de ex. $100_{10}$ ${\ displaystyle 100_ {10}}$ ${\ displaystyle 100_ {10}}$ atunci noi avem: $valore=100_{10}\to V=100_{10}=64_{16}=01100100_{2}$ ${\ displaystyle value = 100_ {10} \ to V = 100_ {10} = 64_ {16} = 01100100_ {2}}$ ${\ displaystyle value = 100_ {10} \ to V = 100_ {10} = 64_ {16} = 01100100_ {2}}$ . În acest caz, bitul de semn este zero și, prin urmare, codificarea este corectă.

Dacă, pe de altă parte, numărul întreg este de ex. 250 atunci avem: $V=250_{10}=FA_{16}=11111010_{2}$ ${\ displaystyle V = 250_ {10} = FA_ {16} = 11111010_ {2}}$ ${\ displaystyle V = 250_ {10} = FA_ {16} = 11111010_ {2}}$ . În acest caz, bitul de semn este 1 și, prin urmare, în faza de decodare ar reprezenta un număr negativ, prin urmare trebuie adăugate zerourile din partea de sus. Categoric $valore=250\to V=250_{10}=FA_{16}=00FA_{16}=0000000011111010_{2}$ ${\ displaystyle value = 250 \ to V = 250_ {10} = FA_ {16} = 00FA_ {16} = 0000000011111010_ {2}}$ ${\ displaystyle value = 250 \ to V = 250_ {10} = FA_ {16} = 00FA_ {16} = 0000000011111010_ {2}}$ . După cum puteți vedea, adăugând zerourile principale, bitul de semn este corect zero.

INTEGER Negative

Pentru numerele întregi negative, se folosește complementul valorii celor doi . Acest lucru asigură faptul că bitul de semn este întotdeauna negativ. În special, pașii de urmat sunt:

codifică $\left|valore\right|$ ${\ displaystyle \ left | value \ right |}$ ${\ displaystyle \ left | value \ right |}$ cu regulile indicate mai sus
se calculează complementul unu , adică este negat bit cu bit
se adaugă în cele din urmă la numărul obținut $+1_{2}$ ${\ displaystyle + 1_ {2}}$ ${\ displaystyle + 1_ {2}}$

De exemplu, dacă valoarea = -100 avem:

$\left|valore\right|=\left|-100\right|=100_{10}=01100100_{2}$ ${\ displaystyle \ left | value \ right | = \ left | -100 \ right | = 100_ {10} = 01100100_ {2}}$ ${\ displaystyle \ left | value \ right | = \ left | -100 \ right | = 100_ {10} = 01100100_ {2}}$ (vezi de ex. INTEGER pozitiv)
complement la 1: $01100100_{2}->10011011_{2}$ ${\ displaystyle 01100100_ {2} -> 10011011_ {2}}$ ${\ displaystyle 01100100_ {2} -> 10011011_ {2}}$
a adauga $+1_{2}$ ${\ displaystyle + 1_ {2}}$ ${\ displaystyle + 1_ {2}}$ . Se obține $10011011_{2}+1_{2}=10011100_{2}$ ${\ displaystyle 10011011_ {2} + 1_ {2} = 10011100_ {2}}$ ${\ displaystyle 10011011_ {2} + 1_ {2} = 10011100_ {2}}$

Prin urmare $valore=-100\to V=10011100_{2}=9C_{16}$ ${\ displaystyle value = -100 \ to V = 10011100_ {2} = 9C_ {16}}$ ${\ displaystyle value = -100 \ to V = 10011100_ {2} = 9C_ {16}}$

Dacă în schimb valoarea = -250 avem:

$\left|valore\right|=\left|-250\right|=250_{10}=0000000011111010_{2}$ ${\ displaystyle \ left | value \ right | = \ left | -250 \ right | = 250_ {10} = 0000000011111010_ {2}}$ ${\ displaystyle \ left | value \ right | = \ left | -250 \ right | = 250_ {10} = 0000000011111010_ {2}}$ (vezi de ex. INTEGER pozitiv)
complement la 1: $0000000011111010_{2}->1111111100000101_{2}$ ${\ displaystyle 0000000011111010_ {2} -> 1111111100000101_ {2}}$ ${\ displaystyle 0000000011111010_ {2} -> 1111111100000101_ {2}}$
a adauga $+1_{2}$ ${\ displaystyle + 1_ {2}}$ ${\ displaystyle + 1_ {2}}$ . Îl înțelegi $1111111100000101_{2}+1_{2}=1111111100000110_{2}$ ${\ displaystyle 1111111100000101_ {2} + 1_ {2} = 1111111100000110_ {2}}$ ${\ displaystyle 1111111100000101_ {2} + 1_ {2} = 1111111100000110_ {2}}$

Prin urmare $valore=-250\to V=1111111100000110_{2}=FF06_{16}$ ${\ displaystyle value = -250 \ to V = 1111111100000110_ {2} = FF06_ {16}}$ ${\ displaystyle value = -250 \ to V = 1111111100000110_ {2} = FF06_ {16}}$

Codare OCTECT STRING

O mare varietate de șiruri sunt definite în ASN.1, dar OCTECT STRING este cel fundamental. În acest caz, fiecare caracter ocupă 1 octet și se utilizează codarea ASCII .

De exemplu, OCTECT STRING "salut" este codificat în 4 octeți în $6369616F_{16}$ ${\ displaystyle 6369616F_ {16}}$ ${\ displaystyle 6369616F_ {16}}$

Codificare IDENTIFICATOR DE OBIECT

Un IDENTIFICATOR DE OBIECT (abreviat este OID) este un identificator unic al unui câmp din MIB .

Un OID este alcătuit din n numere împărțite la n-1 puncte. Un exemplu de OID este următorul: 1.2.250.1.16.9

Pașii pentru codificarea unui OID sunt după cum urmează:

valoarea este plasată în primul octet $40*primonumero+secondonumero$ ${\ displaystyle 40 * primul număr + al doilea număr}$ ${\ displaystyle 40 * primul număr + al doilea număr}$
celelalte numere sunt codificate în octeți separați cu următoarele reguli:
1. de sine $numero<=127$ ${\ displaystyle number <= 127}$ ${\ displaystyle number <= 127}$ folosim pur și simplu reprezentarea binară a numărului
2. de sine $n$ $tu$ $m$ $Și$ $r$ $sau$ $>$ $127$ {\ displaystyle number> 127} ${\ displaystyle number> 127}$ reprezentarea binară a numărului este utilizată cu:
  1. un 0 intercalat la fiecare 7 biți
  2. un 1 ca primul bit al primului octet

De exemplu, codificarea 1.2.250.1.16.9:

$primobyte=40*1+2=42_{10}=2A_{16}$ ${\ displaystyle primobyte = 40 * 1 + 2 = 42_ {10} = 2A_ {16}}$ ${\ displaystyle primobyte = 40 * 1 + 2 = 42_ {10} = 2A_ {16}}$
$250_{10}=FA_{16}=11111010_{2}$ ${\ displaystyle 250_ {10} = FA_ {16} = 11111010_ {2}}$ ${\ displaystyle 250_ {10} = FA_ {16} = 11111010_ {2}}$ -> 1 000 0001 | 0 111 1010 -> 1000 0001 0111 1010 = $817A_{16}$ ${\ displaystyle 817A_ {16}}$ ${\ displaystyle 817A_ {16}}$
$1_{10}=01_{16}$ ${\ displaystyle 1_ {10} = 01_ {16}}$ ${\ displaystyle 1_ {10} = 01_ {16}}$
$16_{10}=10_{16}$ ${\ displaystyle 16_ {10} = 10_ {16}}$ ${\ displaystyle 16_ {10} = 10_ {16}}$
$9_{10}=09_{16}$ ${\ displaystyle 9_ {10} = 09_ {16}}$ ${\ displaystyle 9_ {10} = 09_ {16}}$

Deci 1.2.250.1.16.9 -> 2A 817A 01 10 09 = $2A817A011009_{16}$ ${\ displaystyle 2A817A011009_ {16}}$ ${\ displaystyle 2A817A011009_ {16}}$

Elemente conexe

linkuri externe

( EN ) Olivier Dubuisson - ASN.1: Communication Between Heterogeneous Systems - Carte PDF gratuită
( EN ) Professor John Larmouth - ASN.1 Complete - Carte PDF gratuită

Portal IT : accesați intrările Wikipedia care se ocupă cu IT