Мастера DELPHI, Delphi programming community Рейтинг@Mail.ru Титульная страница Поиск, карта сайта Написать письмо 
| Новости |
Новости сайта
Поиск |
Поиск по лучшим сайтам о Delphi
FAQ |
Огромная база часто задаваемых вопросов и, конечно же, ответы к ним ;)
Статьи |
Подборка статей на самые разные темы. Все о DELPHI
Книги |
Новинки книжного рынка
Новости VCL
Обзор свежих компонент со всего мира, по-русски!
|
| Форумы
Здесь вы можете задать свой вопрос и наверняка получите ответ
| ЧАТ |
Место для общения :)
Орешник
Коллекция курьезных вопросов из форумов
Основная («Начинающим»)/ Базы / WinAPI / Компоненты / Сети / Media / Игры / Corba и COM / KOL / FreePascal / .Net / Прочее / rsdn.org

 
Чтобы не потерять эту дискуссию, сделайте закладку « предыдущая ветвь | форум | следующая ветвь »
Страницы: 1 2 3 4 5

Алгоритм контрольной суммы Флетчера


cryptologic ©   (24.03.21 16:47

Попытался реализовать  на Delphi алгоритм функции контроля четности Флетчера
Читал https://ru.wikipedia.org/wiki/Контрольная_сумма_Флетчера
Но, что то не до конца все понял, сделал на столько сколько понял, если кому интересно присоединяйтесь позаморачиваемся.

unit Fletcher;

(************************************************************************* ******
 Implementation of agorhythm "Fletcher"
 Autor by SUPERBOT
 Source Linck https://en.wikipedia.org/wiki/Fletcher%27s_checksum
 Source Linck https://ru.wikipedia.org/wiki/Контрольная_сумма_Флетчера
*******************************************************************************)

interface
uses SysUtils;
   
function Fletcher16(AStrData: AnsiString): UInt16;
function Fletcher32(AStrData: AnsiString): UInt32;
function Fletcher64(AStrData: AnsiString): UInt64;

implementation
{---------------------------------- Fletcher16 --------------------------------}
function Fletcher16(AStrData: AnsiString): UInt16;
var
 sum1, sum2 : UInt16;
 ch: AnsiChar;
begin
 sum1 := 0;
 sum2 := 0;
 for ch in AStrData do
 begin
   sum1 := (sum1 + Byte(ch)) mod $ff;
   sum2 := (sum2 + sum1) mod $ff;
 end;
 Result := (sum2 shl 8) or sum1;
end;

{-------------------------------- Fletcher32 ----------------------------------}
function Fletcher32(AStrData: AnsiString): UInt32;
var
 sum1, sum2: UInt32;
 ch: AnsiChar;
begin
 sum1 := 0;
 sum2 := 0;
 for ch in AStrData do
 begin
   sum1 := (sum1 + Byte(ch)) mod $ffff;
   sum2 := (sum2 + sum2) mod $ffff;
 end;
 Result := (sum2 shl 16) or sum1;
end;

{------------------------ Fletcher64 -----------------------}
function Fletcher64(AStrData: AnsiString): UInt64;
var
 sum1, sum2: UInt64;
 ch: AnsiChar;
begin
 sum1 := 0;
 sum2 := 0;
 for ch in AStrData do
 begin
   sum1 := (sum1 + Byte(ch)) mod $ffff;
   sum2 := (sum2 + sum1) mod $ffff;
 end;
 Result := (sum2 shl 16) or sum1;
end;

end.


manaka ©   (24.03.21 17:07[1]


> Попытался реализовать  на Delphi алгоритм функции контроля
> четности Флетчера

А он разве не реализован? :(


manaka ©   (24.03.21 17:09[2]


> А он разве не реализован? :(


> Читал https://ru.wikipedia.org/wiki/Контрольная_сумма_Флетчера

Там даже примеры кода есть.

> если кому интересно присоединяйтесь позаморачиваемся.

зачем?


cryptologic ©   (24.03.21 17:12[3]


> manaka ©   (24.03.21 17:07) [1]
>


Где он реализован?


cryptologic ©   (24.03.21 17:14[4]


> manaka ©   (24.03.21 17:09) [2]


Если тебе не зачем, что пишешь сюда?


manaka ©   (24.03.21 17:16[5]


> Если тебе не зачем, что пишешь сюда?

А что, запрещено декретом Совнаркома, что ли?

> Где он реализован?

В Гугле забанили?
писала же:

> Там даже примеры кода есть.


cryptologic ©   (24.03.21 17:21[6]

У меня сомнения вызывают функции Fletcher32 и Fletcher64
какая подача байт должна быть в sum1 по 1 байту или блоками по 4 байта (Fletcher32) байта или блоками по 8 байт в (Fletcher64)


> manaka ©   (24.03.21 17:09) [2]
>

что касается примеров, то это только пример 16 битной функции


cryptologic ©   (24.03.21 17:22[7]


> manaka ©   (24.03.21 17:16) [5]


Много ты там найдешь?


manaka ©   (24.03.21 17:22[8]


>
> что касается примеров, то это только пример 16 битной функции

вроде 32 тоже есть


manaka ©   (24.03.21 17:24[9]


> manaka ©   (24.03.21 17:09) [2]
> > если кому интересно присоединяйтесь позаморачиваемся.
> зачем?

Нормальный, на мой взгляд, вопрос программиста.
Действительно, а зачем?


manaka ©   (24.03.21 17:29[10]

Тем более, в [0] непонятно, а что не так в ВАШЕМ коде?


manaka ©   (24.03.21 17:48[11]


> У меня сомнения вызывают функции Fletcher32 и Fletcher64
> какая подача байт должна быть в sum1 по 1 байту или блоками
> по 4 байта (Fletcher32) байта или блоками по 8 байт в (Fletcher64)

А что нам говорит теория подсчета контрольной суммы Флетчера?


cryptologic ©   (24.03.21 17:50[12]


> manaka ©   (24.03.21 17:29) [10]
> Тем более, в [0] непонятно, а что не так в ВАШЕМ коде?
>
>

Хотя бы потому что элементарная ошибка в функции Fletcher64...
Теперь она выглядит так:

{------------------------ Fletcher64 -----------------------}
function Fletcher64(AStrData: AnsiString): UInt64;
var
 sum1, sum2: UInt64;
 ch: AnsiChar;
begin
 sum1 := 0;
 sum2 := 0;
 for ch in AStrData do
 begin
   sum1 := (sum1 + Byte(ch)) mod $FFFFFFFF;
   sum2 := (sum2 + sum1) mod $FFFFFFFF;
 end;
 Result := (sum2 shl 32) or sum1;
end;


manaka ©   (24.03.21 17:51[13]


> {-------------------------------- Fletcher32 -----------
> -----------------------}
> function Fletcher32(AStrData: AnsiString): UInt32;
> var
>  sum1, sum2: UInt32;
>  ch: AnsiChar;
> begin
>  sum1 := 0;
>  sum2 := 0;
>  for ch in AStrData do
>  begin
>    sum1 := (sum1 + Byte(ch)) mod $ffff;
>    sum2 := (sum2 + sum2) mod $ffff;
>  end;
>  Result := (sum2 shl 16) or sum1;
> end;
>
> {------------------------ Fletcher64 -------------------
> ----}
> function Fletcher64(AStrData: AnsiString): UInt64;
> var
>  sum1, sum2: UInt64;
>  ch: AnsiChar;
> begin
>  sum1 := 0;
>  sum2 := 0;
>  for ch in AStrData do
>  begin
>    sum1 := (sum1 + Byte(ch)) mod $ffff;
>    sum2 := (sum2 + sum1) mod $ffff;
>  end;
>  Result := (sum2 shl 16) or sum1;
> end;

Найдите два различия? Я не нашла... (((


manaka ©   (24.03.21 17:52[14]


> Хотя бы потому что элементарная ошибка в функции Fletcher64.
> ..
> Теперь она выглядит так:

Ошибка то в чем?


manaka ©   (24.03.21 17:53[15]

Что то я сегодня "не в контакте".
Завтра перечитаю, постараюсь понять.


cryptologic ©   (24.03.21 18:04[16]


> manaka ©   (24.03.21 17:29) [10]


Если тебе так все дается легко и без проблем конвертируй мне этот код на delphi я даже тысячу руб. готов заплатить

"""
Python implementation of the COMP128 (aka A3A8) algorithm version 2 and 3
Author: Tamas Jos (@skelsec)
Email:  info [at] skelsec.com
"""
table0=[197, 235, 60, 151, 98, 96, 3, 100, 248, 118, 42, 117, 172, 211, 181, 203, 61,
 126, 156, 87, 149, 224, 55, 132, 186, 63, 238, 255, 85, 83, 152, 33, 160,
 184, 210, 219, 159, 11, 180, 194, 130, 212, 147, 5, 215, 92, 27, 46, 113,
 187, 52, 25, 185, 79, 221, 48, 70, 31, 101, 15, 195, 201, 50, 222, 137,
 233, 229, 106, 122, 183, 178, 177, 144, 207, 234, 182, 37, 254, 227, 231, 54,
 209, 133, 65, 202, 69, 237, 220, 189, 146, 120, 68, 21, 125, 38, 30, 2,
 155, 53, 196, 174, 176, 51, 246, 167, 76, 110, 20, 82, 121, 103, 112, 56,
 173, 49, 217, 252, 0, 114, 228, 123, 12, 93, 161, 253, 232, 240, 175, 67,
 128, 22, 158, 89, 18, 77, 109, 190, 17, 62, 4, 153, 163, 59, 145, 138,
 7, 74, 205, 10, 162, 80, 45, 104, 111, 150, 214, 154, 28, 191, 169, 213,
 88, 193, 198, 200, 245, 39, 164, 124, 84, 78, 1, 188, 170, 23, 86, 226,
 141, 32, 6, 131, 127, 199, 40, 135, 16, 57, 71, 91, 225, 168, 242, 206,
 97, 166, 44, 14, 90, 236, 239, 230, 244, 223, 108, 102, 119, 148, 251, 29,
 216, 8, 9, 249, 208, 24, 105, 94, 34, 64, 95, 115, 72, 134, 204, 43,
 247, 243, 218, 47, 58, 73, 107, 241, 179, 116, 66, 36, 143, 81, 250, 139,
 19, 13, 142, 140, 129, 192, 99, 171, 157, 136, 41, 75, 35, 165, 26 ]

table1=[170, 42, 95, 141, 109, 30, 71, 89, 26, 147, 231, 205, 239, 212, 124, 129, 216,
 79, 15, 185, 153, 14, 251, 162, 0, 241, 172, 197, 43, 10, 194, 235, 6,
 20, 72, 45, 143, 104, 161, 119, 41, 136, 38, 189, 135, 25, 93, 18, 224,
 171, 252, 195, 63, 19, 58, 165, 23, 55, 133, 254, 214, 144, 220, 178, 156,
 52, 110, 225, 97, 183, 140, 39, 53, 88, 219, 167, 16, 198, 62, 222, 76,
 139, 175, 94, 51, 134, 115, 22, 67, 1, 249, 217, 3, 5, 232, 138, 31,
 56, 116, 163, 70, 128, 234, 132, 229, 184, 244, 13, 34, 73, 233, 154, 179,
 131, 215, 236, 142, 223, 27, 57, 246, 108, 211, 8, 253, 85, 66, 245, 193,
 78, 190, 4, 17, 7, 150, 127, 152, 213, 37, 186, 2, 243, 46, 169, 68,
 101, 60, 174, 208, 158, 176, 69, 238, 191, 90, 83, 166, 125, 77, 59, 21,
 92, 49, 151, 168, 99, 9, 50, 146, 113, 117, 228, 65, 230, 40, 82, 54,
 237, 227, 102, 28, 36, 107, 24, 44, 126, 206, 201, 61, 114, 164, 207, 181,
 29, 91, 64, 221, 255, 48, 155, 192, 111, 180, 210, 182, 247, 203, 148, 209,
 98, 173, 11, 75, 123, 250, 118, 32, 47, 240, 202, 74, 177, 100, 80, 196,
 33, 248, 86, 157, 137, 120, 130, 84, 204, 122, 81, 242, 188, 200, 149, 226,
 218, 160, 187, 106, 35, 87, 105, 96, 145, 199, 159, 12, 121, 103, 112]

def comp128v23_internal(KXOR,RAND):
"""Internal part of the COMP128v23 algo, should not be called manually
"""
temp = [0] * 16
KM_RM = RAND + KXOR

for i in range(5):
 for z in range(16):
  temp[z] = table0[table1[KM_RM[16+z]] ^ KM_RM[z] ]

 j = 0
 while ( (1 << i) > j):
  k = 0
  while ( (1 << (4 - i)) > k ):
   KM_RM[((2 * k + 1) << i )+j] = table0[table1[temp[(k << i) + j]] ^ (KM_RM[(k << i) + 16 + j])]
   KM_RM[ (k << (i + 1)) + j] = temp[(k << i) + j]
   k = k+1
  j = j + 1
 
output = [0]*16

for i in range(16):
 for j in range(8):
  output[i] = output[i] ^ (((KM_RM[(19 * (j + 8 * i) + 19) % 256 / 8] >> (3 * j + 3) % 8) & 1) << j)

return output

def comp128v23(K, RAND, version = 2):
"""The entry point for COMP128v2 and COMP128v3 algorithm
K = The secret Ki number (that should be inside of your SIM card) - Format: list of integers
RAND = The random number generated by the tower - Format: list of integers
version = Version selecting integer (can be 2 or 3) - Format: integer
"""

assert version in [2,3] , "This function only support COMP128 version 2 and 3!"
assert len(K) == 16     , "Ki incorrect (length must be 16)"
assert len(RAND) == 16  , "RAND incorrect (length must be 16)"

K_MIX = [0]*16
RAND_MIX = [0]*16
KATYVASZ = [0]*16
output = [0]*16

for i in range(8):
 K_MIX[i] = K[15 - i]
 K_MIX[15 - i] = K[i]

for i in range(8):
 RAND_MIX[i] = RAND[15 - i]
 RAND_MIX[15 - i] = RAND[i]

for i in range(16):
 KATYVASZ[i] = K_MIX[i] ^ RAND_MIX[i]

for i in range(8):
 RAND_MIX = comp128v23_internal(KATYVASZ,RAND_MIX)

for i in range(16):
 output[i] = RAND_MIX[15-i]


if version == 2:
 output[15] = 0
 output[14] = 4 * (output[14] >> 2)

s = 8
i = 0
while i < 4:
 output[s+i-4] = output[s+i]
 output[s+i] = output[s+i+4]
 i = i+1

#the algorithm uses 16 bytes until this point, but only 12 bytes are effective
#also 12 bytes coming out from the SIM card

output_final = output[:12]
return output_final


def hex2intarr(input):
"""converts hex string to an array of integers
"""
return map(lambda a: int(a.encode('hex'),16), (a for a in input.decode('hex')))
 
def intarr2hex(input):
"""converts array of integers to hex strings
"""
return ''.join('{:02x}'.format(x) for x in input).upper()

if __name__ == '__main__':
import argparse

parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('Ki', metavar='Ki', default = "00000000000000000000000000000000" ,nargs='?', help='The super secret Ki key')
   #parser.add_argument('Ki', metavar='Ki', default = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" ,nargs='?', help='The super secret Ki key')
parser.add_argument('RAND', metavar='RAND', default = "00000000000000000000000000000000", nargs='?', help='The RANDom number you recieve from the tower')
   # parser.add_argument('RAND', metavar='RAND', default = "6E6989BE6CEE7154543770AE80B1EF0D", nargs='?', help='The RANDom number you recieve from the tower')
parser.add_argument('version', metavar='version', default = 3, nargs='?', help='The version of the COMP128 algo you wish to use (options: 2 or 3)')

args = parser.parse_args()

Ki = hex2intarr(args.Ki)
RAND = hex2intarr(args.RAND)
version = args.version

print '----------- INPUT  -------------'
print 'COMP128 version ' + str(version)
print 'Ki:      ' + intarr2hex(Ki)
print 'RAND:    ' + intarr2hex(RAND)

OUTPUT = comp128v23(Ki, RAND, version)
SRES = OUTPUT[:4]
Kc = OUTPUT[4:]

print '----------- OUTPUT -------------'
print "SIM OUTPUT:" + intarr2hex(OUTPUT)
print "SRES:  " + intarr2hex(SRES)
print "Kc:    " + intarr2hex(Kc)


cryptologic ©   (24.03.21 18:12[17]


> cryptologic ©   (24.03.21 18:04) [16]
>

Это тот же код для поста cryptologic ©   (24.03.21 18:04) [16]  но другая его реализация только на СИ или С++  так, что бы понятнее было из двух исходников один сконвертировать,  

manaka © - если ты так во всем очень сильно разбираешься то транслируй код на Delphi, я вознаграждение кину


/*! \file comp128v23.c
* COMP128 version 2 and 3 implementation, common algorithm used for GSM Authentication (A3/A8).
*
* This code is a C conversion of the original code by Tamas Jos <info@skelsec.com> from:
* - original (out of service): http://www.hackingprojects.net/
* - original (archive): https://web.archive.org/web/20130730113347/http://www.hackingprojects.net/
* - new site: https://github.com/skelsec/COMP128
*/
/*
* (C) 2013 by Kévin Redon <kevredon@mail.tsaitgaist.info>
*
* All Rights Reserved
*
* SPDX-License-Identifier: GPL-2.0+
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
*/

#include <stdint.h>
#include <string.h>

/*! \addtogroup auth
*  @{
* \file comp128v23.c */

static const uint8_t table0[256] = {
197, 235, 60, 151, 98, 96, 3, 100, 248, 118, 42, 117, 172, 211, 181, 203, 61,
126, 156, 87, 149, 224, 55, 132, 186, 63, 238, 255, 85, 83, 152, 33, 160,
184, 210, 219, 159, 11, 180, 194, 130, 212, 147, 5, 215, 92, 27, 46, 113,
187, 52, 25, 185, 79, 221, 48, 70, 31, 101, 15, 195, 201, 50, 222, 137,
233, 229, 106, 122, 183, 178, 177, 144, 207, 234, 182, 37, 254, 227, 231, 54,
209, 133, 65, 202, 69, 237, 220, 189, 146, 120, 68, 21, 125, 38, 30, 2,
155, 53, 196, 174, 176, 51, 246, 167, 76, 110, 20, 82, 121, 103, 112, 56,
173, 49, 217, 252, 0, 114, 228, 123, 12, 93, 161, 253, 232, 240, 175, 67,
128, 22, 158, 89, 18, 77, 109, 190, 17, 62, 4, 153, 163, 59, 145, 138,
7, 74, 205, 10, 162, 80, 45, 104, 111, 150, 214, 154, 28, 191, 169, 213,
88, 193, 198, 200, 245, 39, 164, 124, 84, 78, 1, 188, 170, 23, 86, 226,
141, 32, 6, 131, 127, 199, 40, 135, 16, 57, 71, 91, 225, 168, 242, 206,
97, 166, 44, 14, 90, 236, 239, 230, 244, 223, 108, 102, 119, 148, 251, 29,
216, 8, 9, 249, 208, 24, 105, 94, 34, 64, 95, 115, 72, 134, 204, 43,
247, 243, 218, 47, 58, 73, 107, 241, 179, 116, 66, 36, 143, 81, 250, 139,
19, 13, 142, 140, 129, 192, 99, 171, 157, 136, 41, 75, 35, 165, 26
}, table1[256] = {
170, 42, 95, 141, 109, 30, 71, 89, 26, 147, 231, 205, 239, 212, 124, 129, 216,
79, 15, 185, 153, 14, 251, 162, 0, 241, 172, 197, 43, 10, 194, 235, 6,
20, 72, 45, 143, 104, 161, 119, 41, 136, 38, 189, 135, 25, 93, 18, 224,
171, 252, 195, 63, 19, 58, 165, 23, 55, 133, 254, 214, 144, 220, 178, 156,
52, 110, 225, 97, 183, 140, 39, 53, 88, 219, 167, 16, 198, 62, 222, 76,
139, 175, 94, 51, 134, 115, 22, 67, 1, 249, 217, 3, 5, 232, 138, 31,
56, 116, 163, 70, 128, 234, 132, 229, 184, 244, 13, 34, 73, 233, 154, 179,
131, 215, 236, 142, 223, 27, 57, 246, 108, 211, 8, 253, 85, 66, 245, 193,
78, 190, 4, 17, 7, 150, 127, 152, 213, 37, 186, 2, 243, 46, 169, 68,
101, 60, 174, 208, 158, 176, 69, 238, 191, 90, 83, 166, 125, 77, 59, 21,
92, 49, 151, 168, 99, 9, 50, 146, 113, 117, 228, 65, 230, 40, 82, 54,
237, 227, 102, 28, 36, 107, 24, 44, 126, 206, 201, 61, 114, 164, 207, 181,
29, 91, 64, 221, 255, 48, 155, 192, 111, 180, 210, 182, 247, 203, 148, 209,
98, 173, 11, 75, 123, 250, 118, 32, 47, 240, 202, 74, 177, 100, 80, 196,
33, 248, 86, 157, 137, 120, 130, 84, 204, 122, 81, 242, 188, 200, 149, 226,
218, 160, 187, 106, 35, 87, 105, 96, 145, 199, 159, 12, 121, 103, 112
};

static void
_comp128v23_internal(uint8_t *output, const uint8_t *kxor, const uint8_t *rand)
{
uint8_t temp[16];
uint8_t km_rm[32];
uint8_t i,j,k,z;

memset(temp, 0, sizeof(temp));
memcpy(km_rm, rand, 16);
memcpy(km_rm + 16, kxor, 16);

for (i=0; i<5; i++) {
 for (z=0; z<16; z++) {
  temp[z] = table0[table1[km_rm[16+z]]^km_rm[z]];
 }
 j=0;
 while ((1<<i)>j) {
  k = 0;
  while ((1<<(4-i))>k) {
   km_rm[((2*k+1)<<i)+j] = table0[table1[temp[(k<<i)+j]]^(km_rm[(k<<i)+16+j])];
   km_rm[(k<<(i+1))+j] = temp[(k<<i)+j];
   k++;
  }
  j++;
 }
}

memset(output,0,16);

for (i=0; i<16; i++) {
 for (j=0; j<8; j++) {
  output[i] ^= (((km_rm[(19*(j+8*i)+19)%256/8]>>(3*j+3)%8)&1)<< j);
 }
}
}

/*! Perform COMP128v3 algorithm
*  \param[in] ki Secret Key K(i) of subscriber
*  \param[in] rand Random Challenge
*  \param[out] sres user-supplied buffer for storing computed SRES value
*  \param[out] kc user-supplied buffer for storing computed Kc value
*  \returns 0 */
int
comp128v3(const uint8_t *ki, const uint8_t *rand, uint8_t *sres, uint8_t *kc)
{
uint8_t k_mix[16];
uint8_t rand_mix[16];
uint8_t katyvasz[16];
uint8_t output[16];
uint8_t i;

memset(k_mix, 0, sizeof(k_mix));
memset(rand_mix, 0, sizeof(rand_mix));
memset(katyvasz, 0, sizeof(katyvasz));
memset(output, 0, sizeof(output));

for (i=0; i<8; i++) {
 k_mix[i] = ki[15 - i];
 k_mix[15 - i] = ki[i];
}

for (i=0; i<8; i++) {
 rand_mix[i] = rand[15 - i];
 rand_mix[15 - i] = rand[i];
}

for (i=0; i<16; i++) {
 katyvasz[i] = k_mix[i]^rand_mix[i];
}

for (i=0; i<8; i++) {
 _comp128v23_internal(rand_mix,katyvasz,rand_mix);
}

for (i=0; i<16; i++) {
 output[i] = rand_mix[15-i];
}

memmove(output + 4, output + 8, 8); /* ignore bytes 4..7 */

/* the algorithm uses 16 bytes until this point, but only 12 bytes are effective
 * also 12 bytes coming out from the SIM card */
memcpy(sres, output, 4);
memcpy(kc, output + 4, 8);

return 0;
}

/*! Perform COMP128v2 algorithm
*  \param[in] ki Secret Key K(i) of subscriber
*  \param[in] rand Random Challenge
*  \param[out] sres user-supplied buffer for storing computed SRES value
*  \param[out] kc user-supplied buffer for storing computed Kc value
*  \returns 0 */
int
comp128v2(const uint8_t *ki, const uint8_t *rand, uint8_t *sres, uint8_t *kc)
{
int r = comp128v3(ki, rand, sres, kc);
kc[7] = 0; /* 10 last bits of Kc forced to 0 */
kc[6] &= 0xfc;
return r;
}


Rouse_ ©   (24.03.21 21:15[18]

А зачем это тебе если ты простейший сишный исходник на дельфю конвернуть не можешь?

Ну на, делов на 5 минут с перекуром.

program comp128v23;

{$APPTYPE CONSOLE}

{$R *.res}

uses
 Windows,
 System.SysUtils;

const
 table0: array [0..255] of Byte = (
   197, 235, 60, 151, 98, 96, 3, 100, 248, 118, 42, 117, 172, 211, 181, 203, 61,
   126, 156, 87, 149, 224, 55, 132, 186, 63, 238, 255, 85, 83, 152, 33, 160,
   184, 210, 219, 159, 11, 180, 194, 130, 212, 147, 5, 215, 92, 27, 46, 113,
   187, 52, 25, 185, 79, 221, 48, 70, 31, 101, 15, 195, 201, 50, 222, 137,
   233, 229, 106, 122, 183, 178, 177, 144, 207, 234, 182, 37, 254, 227, 231, 54,
   209, 133, 65, 202, 69, 237, 220, 189, 146, 120, 68, 21, 125, 38, 30, 2,
   155, 53, 196, 174, 176, 51, 246, 167, 76, 110, 20, 82, 121, 103, 112, 56,
   173, 49, 217, 252, 0, 114, 228, 123, 12, 93, 161, 253, 232, 240, 175, 67,
   128, 22, 158, 89, 18, 77, 109, 190, 17, 62, 4, 153, 163, 59, 145, 138,
   7, 74, 205, 10, 162, 80, 45, 104, 111, 150, 214, 154, 28, 191, 169, 213,
   88, 193, 198, 200, 245, 39, 164, 124, 84, 78, 1, 188, 170, 23, 86, 226,
   141, 32, 6, 131, 127, 199, 40, 135, 16, 57, 71, 91, 225, 168, 242, 206,
   97, 166, 44, 14, 90, 236, 239, 230, 244, 223, 108, 102, 119, 148, 251, 29,
   216, 8, 9, 249, 208, 24, 105, 94, 34, 64, 95, 115, 72, 134, 204, 43,
   247, 243, 218, 47, 58, 73, 107, 241, 179, 116, 66, 36, 143, 81, 250, 139,
   19, 13, 142, 140, 129, 192, 99, 171, 157, 136, 41, 75, 35, 165, 26);
 table1: array [0..255] of Byte = (
   170, 42, 95, 141, 109, 30, 71, 89, 26, 147, 231, 205, 239, 212, 124, 129, 216,
   79, 15, 185, 153, 14, 251, 162, 0, 241, 172, 197, 43, 10, 194, 235, 6,
   20, 72, 45, 143, 104, 161, 119, 41, 136, 38, 189, 135, 25, 93, 18, 224,
   171, 252, 195, 63, 19, 58, 165, 23, 55, 133, 254, 214, 144, 220, 178, 156,
   52, 110, 225, 97, 183, 140, 39, 53, 88, 219, 167, 16, 198, 62, 222, 76,
   139, 175, 94, 51, 134, 115, 22, 67, 1, 249, 217, 3, 5, 232, 138, 31,
   56, 116, 163, 70, 128, 234, 132, 229, 184, 244, 13, 34, 73, 233, 154, 179,
   131, 215, 236, 142, 223, 27, 57, 246, 108, 211, 8, 253, 85, 66, 245, 193,
   78, 190, 4, 17, 7, 150, 127, 152, 213, 37, 186, 2, 243, 46, 169, 68,
   101, 60, 174, 208, 158, 176, 69, 238, 191, 90, 83, 166, 125, 77, 59, 21,
   92, 49, 151, 168, 99, 9, 50, 146, 113, 117, 228, 65, 230, 40, 82, 54,
   237, 227, 102, 28, 36, 107, 24, 44, 126, 206, 201, 61, 114, 164, 207, 181,
   29, 91, 64, 221, 255, 48, 155, 192, 111, 180, 210, 182, 247, 203, 148, 209,
   98, 173, 11, 75, 123, 250, 118, 32, 47, 240, 202, 74, 177, 100, 80, 196,
   33, 248, 86, 157, 137, 120, 130, 84, 204, 122, 81, 242, 188, 200, 149, 226,
   218, 160, 187, 106, 35, 87, 105, 96, 145, 199, 159, 12, 121, 103, 112);

procedure _comp128v23_internal(output, kxor, rand: PByte);
var
 temp: array [0..15] of Byte;
 km_rm: array [0..31] of Byte;
 i,j,k,z: Byte;
begin
 ZeroMemory(@temp[0], SizeOf(temp));
 CopyMemory(@km_rm[0], rand, 16);
 CopyMemory(@km_rm[16], kxor, 16);

 for i := 0 to 4 do
 begin
   for z := 0 to 15 do
     temp[z] := table0[table1[km_rm[16+z]] xor km_rm[z]];

   j := 0;
   while (1 shl i) > j do
   begin
     k := 0;
     while (1 shl (4-i)) > k do
     begin
       km_rm[((2*k+1) shl i)+j] := table0[table1[temp[(k shl i)+j]] xor (km_rm[(k shl i)+16+j])];
       km_rm[(k shl (i+1))+j] := temp[(k shl i)+j];
       Inc(k);
     end;
     Inc(j);
   end;
 end;

 ZeroMemory(output, 16);
 for i := 0 to 15 do
   for j := 0 to 7 do
     output[i] := output[i] xor (((km_rm[(19*(j+8*i)+19) mod 256 div 8] shr (3*j+3) mod 8) and 1) shl j);
end;

///*! Perform COMP128v3 algorithm
//*  \param[in] ki Secret Key K(i) of subscriber
//*  \param[in] rand Random Challenge
//*  \param[out] sres user-supplied buffer for storing computed SRES value
//*  \param[out] kc user-supplied buffer for storing computed Kc value
//*  \returns 0 */
function comp128v3(ki, rand, sres, kc: PByte): Integer;
var
 k_mix: array [0..15] of Byte;
 rand_mix: array [0..15] of Byte;
 katyvasz: array [0..15] of Byte;
 output: array [0..15] of Byte;
 i: Byte;
begin
 ZeroMemory(@k_mix[0], 16);
 ZeroMemory(@rand_mix[0], 16);
 ZeroMemory(@katyvasz[0], 16);
 ZeroMemory(@output[0], 16);

 for i := 0 to 7 do
 begin
   k_mix[i] := ki[15 - i];
   k_mix[15 - i] := ki[i];
 end;

 for i := 0 to 7 do
 begin
   rand_mix[i] := rand[15 - i];
   rand_mix[15 - i] := rand[i];
 end;

 for i := 0 to 15 do
   katyvasz[i] := k_mix[i] xor rand_mix[i];

 for i := 0 to 7 do
   _comp128v23_internal(@rand_mix[0], @katyvasz[0], @rand_mix[0]);

 for i := 0 to 15 do
   output[i] := rand_mix[15-i];

 move(output[8], output[4], 8); //* ignore bytes 4..7 */

///* the algorithm uses 16 bytes until this point, but only 12 bytes are effective
// * also 12 bytes coming out from the SIM card */

 move(output[0], sres[0], 4);
 move(output[4], kc[0], 8);

 Result := 0;
end;

///*! Perform COMP128v2 algorithm
//*  \param[in] ki Secret Key K(i) of subscriber
//*  \param[in] rand Random Challenge
//*  \param[out] sres user-supplied buffer for storing computed SRES value
//*  \param[out] kc user-supplied buffer for storing computed Kc value
//*  \returns 0 */
function comp128v2(ki, rand, sres, kc: PByte): Integer;
begin
 Result := comp128v3(ki, rand, sres, kc);
 kc[7] := 0; //* 10 last bits of Kc forced to 0 */
 kc[6] := kc[6]  and $fc;
end;

begin
 try

 except
   on E: Exception do
     Writeln(E.ClassName, ': ', E.Message);
 end;
end.


cryptologic ©   (24.03.21 22:19[19]


> Rouse_ ©   (24.03.21 21:15) [18]
> А зачем это тебе если ты простейший сишный исходник на дельфю
> конвернуть не можешь?


Могу, но времени нет...  этот код давно валяется уже почти скоро год будет, а руки все не как не доходят, все откладываю да откладываю... куча дел других более важных наваливается. Не тот случай был, что бы все бросить и этой фигней заняться.

Теперь самая главная задача осталась. Как проверить что сей алгоритм рабочий? Кто даст гарантию, что именно этот алгоритм и есть правильный? Может его от фонаря китайские шалопаи слили.

А зачем он мне нужен был вот сейчас уже точно не помню, но вот нужен был...

Ну все равно спасибо товарищ майор или как там вас товарищ полковник.. ;-)


Страницы: 1 2 3 4 5 версия для печати

Написать ответ

Ваше имя (регистрация  E-mail 







Разрешается использование тегов форматирования текста:
<b>жирный</b> <i>наклонный</i> <u>подчеркнутый</u>,
а для выделения текста программ, используйте <code> ... </code>
и не забывайте закрывать теги! </b></i></u></code> :)


Наверх

  Рейтинг@Mail.ru     Титульная страница Поиск, карта сайта Написать письмо