274
317
static int control(ErlDrvData drv_data, unsigned int command, char *buf,
275
318
int len, char **rbuf, int rlen)
277
int klen, dlen, i, j, macsize, from_len, to_len;
320
int klen, dlen, macsize, from_len, to_len, i;
278
321
int base_len, exponent_len, modulo_len;
279
322
int data_len, dsa_p_len, dsa_q_len;
280
int dsa_g_len, dsa_y_len;
281
int rsa_e_len, rsa_n_len;
323
int dsa_s_len, dsa_g_len, dsa_y_len;
324
int rsa_e_len, rsa_n_len, rsa_d_len, padding;
283
unsigned int rsa_s_len;
326
int prime_len, generator;
327
int privkey_len, pubkey_len, dh_p_len, dh_g_len;
328
unsigned int rsa_s_len, j;
284
329
char *key, *key2, *dbuf, *p;
285
330
const_DES_cblock *des_key, *des_key2, *des_key3;
286
331
const unsigned char *des_dbuf;
287
332
BIGNUM *bn_from, *bn_to, *bn_rand, *bn_result;
288
333
BIGNUM *bn_base, *bn_exponent, *bn_modulo;
289
BIGNUM *dsa_p, *dsa_q, *dsa_r, *dsa_s, *dsa_g, *dsa_y;
290
BIGNUM *rsa_n, *rsa_e;
334
BIGNUM *dsa_p, *dsa_q, *dsa_r, *dsa_g, *dsa_y;
335
BIGNUM *rsa_n, *rsa_e, *rsa_d;
336
BIGNUM *dh_p, *dh_g, *privkey, *pubkey;
291
337
DES_cblock *des_ivec;
292
338
ErlDrvBinary *bin;
293
339
DES_key_schedule schedule, schedule2, schedule3;
294
341
/* IDEA_KEY_SCHEDULE idea, idea2; */
295
342
unsigned char hmacbuf[SHA_DIGEST_LENGTH];
296
unsigned char *rsa_s;
343
unsigned char *rsa_s, *dsa_s;
297
344
/* char hmacbuf[SHA_LEN]; */
345
#if SSL_VERSION_0_9_8
346
SHA256_CTX sha256_ctx;
347
SHA512_CTX sha512_ctx;
300
352
int new_ivlen = 0;
666
734
dsa->priv_key = NULL;
667
735
dsa->pub_key = dsa_y;
668
i = DSA_do_verify(hmacbuf, SHA_DIGEST_LENGTH,
736
i = DSA_verify(0, hmacbuf, SHA_DIGEST_LENGTH, dsa_s, dsa_s_len, dsa);
670
737
*rbuf = (char *)(bin = driver_alloc_binary(1));
738
if (bin==NULL) return -1;
742
(bin->orig_bytes)[0] = 1;
744
(bin->orig_bytes)[0] = 0;
750
/* buf = <<data_len:32/integer, data:data_len/binary,
751
* dsa_p_len:32/integer, dsa_p:dsa_p_len/binary,
752
* dsa_q_len:32/integer, dsa_q:dsa_q_len/binary,
753
* dsa_g_len:32/integer, dsa_g:dsa_g_len/binary,
754
* dsa_y_len:32/integer, dsa_y:dsa_y_len/binary,
755
* dsa_x_len:32/integer, dsa_s:dsa_x_len/binary>> */
760
data_len = get_int32(buf + i + j);
761
j += data_len; i += 4;
764
dsa_p_len = get_int32(buf + i + j);
765
j += dsa_p_len; i += 4;
768
dsa_q_len = get_int32(buf + i + j);
769
j += dsa_q_len; i += 4;
772
dsa_g_len = get_int32(buf + i + j);
773
j += dsa_g_len; i += 4;
776
dsa_y_len = get_int32(buf + i + j);
784
SHA1((unsigned char *) (buf + i), data_len, hmacbuf);
787
BN_bin2bn((unsigned char *)(buf + i), dsa_p_len, dsa_p);
788
i += (dsa_p_len + 4);
790
BN_bin2bn((unsigned char *)(buf + i), dsa_q_len, dsa_q);
791
i += (dsa_q_len + 4);
793
BN_bin2bn((unsigned char *)(buf + i), dsa_g_len, dsa_g);
794
i += (dsa_g_len + 4);
796
BN_bin2bn((unsigned char *)(buf + i), dsa_y_len, dsa_y);
797
/* i += (dsa_y_len + 4); */
803
dsa->priv_key = dsa_y;
805
dlen = DSA_size(dsa) + 1;
806
*rbuf = (char *)(bin = driver_alloc_binary(dlen));
807
if (bin==NULL) return -1;
808
i = DSA_sign(NID_sha1,
809
hmacbuf,SHA_DIGEST_LENGTH,
810
(unsigned char *) &bin->orig_bytes[1],
671
813
(bin->orig_bytes)[0] = (char)(i & 0xff);
673
DSA_SIG_free(dsa_sig);
815
return dsa_s_len + 1;
818
case DRV_RSA_VERIFY_MD5:
819
case DRV_RSA_VERIFY_SHA:
678
820
/* buf = <<data_len:32/integer, data:data_len/binary,
679
821
* rsa_s_len:32/integer, rsa_s:rsa_s_len/binary,
680
822
* rsa_e_len:32/integer, rsa_e:rsa_e_len/binary,
715
i = RSA_verify(NID_sha1, hmacbuf, SHA_DIGEST_LENGTH,
716
rsa_s, rsa_s_len, rsa);
857
if(command == DRV_RSA_VERIFY_SHA) {
858
SHA1((unsigned char *) (buf + i), data_len, hmacbuf);
859
i = RSA_verify(NID_sha1, hmacbuf, SHA_DIGEST_LENGTH,
860
rsa_s, rsa_s_len, rsa);
862
MD5((unsigned char *) (buf + i), data_len, hmacbuf);
863
i = RSA_verify(NID_md5, hmacbuf, MD5_DIGEST_LENGTH,
864
rsa_s, rsa_s_len, rsa);
717
867
*rbuf = (char *)(bin = driver_alloc_binary(1));
868
if (bin==NULL) return -1;
718
869
(bin->orig_bytes)[0] = (char)(i & 0xff);
874
case DRV_RSA_SIGN_MD5:
875
case DRV_RSA_SIGN_SHA:
876
/* buf = <<data_len:32/integer, data:data_len/binary,
877
* rsa_e_len:32/integer, rsa_e:rsa_e_len/binary,
878
* rsa_n_len:32/integer, rsa_n:rsa_n_len/binary,
879
* rsa_d_len:32/integer, rsa_d:rsa_d_len/binary>> */
886
data_len = get_int32(buf + i + j);
887
j += data_len; i += 4;
890
rsa_e_len = get_int32(buf + i + j);
891
j += rsa_e_len; i += 4;
894
rsa_n_len = get_int32(buf + i + j);
895
j += rsa_n_len; i += 4;
898
rsa_d_len = get_int32(buf + i + j);
899
j += rsa_d_len; i += 4;
906
BN_bin2bn((unsigned char *)(buf + i), rsa_e_len, rsa_e);
907
i += (rsa_e_len + 4);
909
BN_bin2bn((unsigned char *)(buf + i), rsa_n_len, rsa_n);
910
i += (rsa_n_len + 4);
912
BN_bin2bn((unsigned char *)(buf + i), rsa_d_len, rsa_d);
913
i += (rsa_d_len + 4);
920
dlen = RSA_size(rsa) + 1;
921
*rbuf = (char *)(bin = driver_alloc_binary(dlen));
922
if (bin==NULL) return -1;
924
if (command == DRV_RSA_SIGN_MD5) {
925
MD5((unsigned char *) (buf + i), data_len, hmacbuf);
926
i = RSA_sign(NID_md5,
927
hmacbuf,MD5_DIGEST_LENGTH,
928
(unsigned char *) &bin->orig_bytes[1],
931
SHA1((unsigned char *) (buf + i), data_len, hmacbuf);
932
i = RSA_sign(NID_sha1,
933
hmacbuf,SHA_DIGEST_LENGTH,
934
(unsigned char *) &bin->orig_bytes[1],
938
(bin->orig_bytes)[0] = (char)(i & 0xff);
940
return rsa_s_len + 1;
943
case DRV_RSA_PRIVATE_DECRYPT:
944
case DRV_RSA_PRIVATE_ENCRYPT:
945
/* buf = <<data_len:32/integer, data:data_len/binary,
946
* rsa_e_len:32/integer, rsa_e:rsa_e_len/binary,
947
* rsa_n_len:32/integer, rsa_n:rsa_n_len/binary,
948
* rsa_d_len:32/integer, rsa_d:rsa_d_len/binary,
949
* pad:8/integer >> */
956
data_len = get_int32(buf + i + j);
957
j += data_len; i += 4;
960
rsa_e_len = get_int32(buf + i + j);
961
j += rsa_e_len; i += 4;
964
rsa_n_len = get_int32(buf + i + j);
965
j += rsa_n_len; i += 4;
968
rsa_d_len = get_int32(buf + i + j);
969
j += rsa_d_len; i += 4;
970
padding = *(unsigned char *) (buf+i+j);
977
BN_bin2bn((unsigned char *)(buf + i), rsa_e_len, rsa_e);
978
i += (rsa_e_len + 4);
980
BN_bin2bn((unsigned char *)(buf + i), rsa_n_len, rsa_n);
981
i += (rsa_n_len + 4);
983
BN_bin2bn((unsigned char *)(buf + i), rsa_d_len, rsa_d);
984
i += (rsa_d_len + 4);
988
padding = RSA_NO_PADDING;
991
padding = RSA_PKCS1_PADDING;
994
padding = RSA_PKCS1_OAEP_PADDING;
997
padding = RSA_SSLV23_PADDING;
1008
dlen = RSA_size(rsa) + 1;
1009
*rbuf = (char *)(bin = driver_alloc_binary(dlen));
1010
if (bin==NULL) return -1;
1012
if(command == DRV_RSA_PRIVATE_DECRYPT) {
1013
i = RSA_private_decrypt(data_len, (unsigned char *) (buf+i),
1014
(unsigned char *) &bin->orig_bytes[1],
1017
*rbuf = (char *) (bin = driver_realloc_binary(bin, i+1));
1018
if (*rbuf==NULL) return -1;
1021
i = RSA_private_encrypt(data_len, (unsigned char *) (buf+i),
1022
(unsigned char *) &bin->orig_bytes[1],
1027
(bin->orig_bytes)[0] = 1;
1030
(bin->orig_bytes)[0] = 0;
1035
case DRV_RSA_PUBLIC_ENCRYPT:
1036
case DRV_RSA_PUBLIC_DECRYPT:
1037
/* buf = <<data_len:32/integer, data:data_len/binary,
1038
* rsa_e_len:32/integer, rsa_e:rsa_e_len/binary,
1039
* rsa_n_len:32/integer, rsa_n:rsa_n_len/binary,
1040
* pad:8/integer >> */
1047
data_len = get_int32(buf + i + j);
1048
j += data_len; i += 4;
1051
rsa_e_len = get_int32(buf + i + j);
1052
j += rsa_e_len; i += 4;
1055
rsa_n_len = get_int32(buf + i + j);
1056
j += rsa_n_len; i += 4;
1059
padding = *(unsigned char *) (buf + i + j);
1060
if (len != (13 + j))
1064
i += (data_len + 4);
1066
BN_bin2bn((unsigned char *)(buf + i), rsa_e_len, rsa_e);
1067
i += (rsa_e_len + 4);
1069
BN_bin2bn((unsigned char *)(buf + i), rsa_n_len, rsa_n);
1070
i += (rsa_n_len + 4);
1074
padding = RSA_NO_PADDING;
1077
padding = RSA_PKCS1_PADDING;
1080
padding = RSA_PKCS1_OAEP_PADDING;
1083
padding = RSA_SSLV23_PADDING;
1093
dlen = RSA_size(rsa) + 1;
1095
*rbuf = (char *)(bin = driver_alloc_binary(dlen));
1096
if (bin==NULL) return -1;
1098
if(command == DRV_RSA_PUBLIC_ENCRYPT) {
1099
i = RSA_public_encrypt(data_len, (unsigned char *) (buf+i),
1100
(unsigned char *) &bin->orig_bytes[1],
1103
i = RSA_public_decrypt(data_len, (unsigned char *) (buf+i),
1104
(unsigned char *) &bin->orig_bytes[1],
1107
*rbuf = (char *) (bin = driver_realloc_binary(bin, i+1));
1108
if (*rbuf==NULL) return -1;
1114
(bin->orig_bytes)[0] = 1;
1117
/* ERR_load_crypto_strings(); */
1118
/* fprintf(stderr, "%d: %s \r\n", __LINE__, ERR_reason_error_string(ERR_get_error())); */
1119
(bin->orig_bytes)[0] = 0;
723
1124
case DRV_CBC_AES128_ENCRYPT:
724
1125
case DRV_CBC_AES256_ENCRYPT:
725
1126
case DRV_CBC_AES128_DECRYPT:
778
1180
if (len != dlen * 2)
780
1182
*rbuf = (char *)(bin = driver_alloc_binary(dlen));
1183
if (bin==NULL) return -1;
781
1184
p = bin->orig_bytes,
782
1185
dbuf = buf + dlen;
783
1186
for (key = buf, key2 = dbuf; key != dbuf; ++key, ++key2, ++p)
784
1187
*p = *key ^ *key2;
1191
case DRV_DH_GENERATE_PARAMS:
1192
/* buf = <<PrimeLen:32 Generator:32>> */
1195
prime_len = get_int32(buf);
1196
generator = get_int32(buf+4);
1197
dh_params = DH_generate_parameters(prime_len, generator, NULL, NULL);
1200
dh_p_len = BN_num_bytes(dh_params->p);
1201
dh_g_len = BN_num_bytes(dh_params->g);
1202
*rbuf = (char *)(bin = driver_alloc_binary(1+4+4+dh_g_len+dh_p_len));
1203
if (bin==NULL) return -1;
1204
(bin->orig_bytes)[0] = 1;
1205
put_int32(bin->orig_bytes+1, dh_p_len);
1206
BN_bn2bin(dh_params->p, bin->orig_bytes+5);
1207
put_int32(bin->orig_bytes+5+dh_p_len, dh_g_len);
1208
BN_bn2bin(dh_params->g, bin->orig_bytes+5+dh_p_len+4);
1210
*rbuf = (char *)(bin = driver_alloc_binary(1));
1211
if (bin==NULL) return -1;
1212
(bin->orig_bytes)[0] = 0;
1219
/* buf = <<dh_p_len:32/integer, dh_p:dh_p_len/binary,
1220
* dh_g_len:32/integer, dh_g:dh_g_len/binary>> */
1223
if(len < 8) return -1;
1224
dh_p_len = get_int32(buf + i + j);
1225
j += dh_p_len; i += 4;
1226
if (len < (8 + j)) return -1;
1227
dh_g_len = get_int32(buf + i + j);
1228
j += dh_g_len; i += 4;
1229
if(len != (8+j)) return -1;
1232
BN_bin2bn((unsigned char *)(buf + i), dh_p_len, dh_p);
1233
i += (dh_p_len + 4);
1235
BN_bin2bn((unsigned char *)(buf + i), dh_g_len, dh_g);
1236
/* i += (dsa_g_len + 4); */
1238
dh_params = DH_new();
1239
dh_params->p = dh_p;
1240
dh_params->g = dh_g;
1243
*rbuf = (char *)(bin = driver_alloc_binary(4));
1244
if (bin==NULL) return -1;
1245
if(DH_check(dh_params, &i)) {
1246
put_int32(bin->orig_bytes, i);
1249
put_int32(bin->orig_bytes, -1);
1255
case DRV_DH_GENERATE_KEY:
1256
/* buf = <<key_len:32, key:key_len/binary, *
1257
* dh_p_len:32/integer, dh_p:dh_p_len/binary, *
1258
* dh_g_len:32/integer, dh_g:dh_g_len/binary>> */
1261
if(len < 12) return -1;
1262
base_len = get_int32(buf + i + j);
1263
j += base_len; i += 4;
1264
if (len < (12 + j)) return -1;
1265
dh_p_len = get_int32(buf + i + j);
1266
j += dh_p_len; i += 4;
1267
if (len < (12 + j)) return -1;
1268
dh_g_len = get_int32(buf + i + j);
1269
j += dh_g_len; i += 4;
1270
if(len != (12 + j)) return -1;
1274
BN_bin2bn((unsigned char *)(buf + i), base_len, bn_base);
1276
i += (base_len + 4);
1278
BN_bin2bn((unsigned char *)(buf + i), dh_p_len, dh_p);
1279
i += (dh_p_len + 4);
1281
BN_bin2bn((unsigned char *)(buf + i), dh_g_len, dh_g);
1282
/* i += (dsa_g_len + 4); */
1284
dh_params = DH_new();
1285
dh_params->p = dh_p;
1286
dh_params->g = dh_g;
1288
dh_params->priv_key = bn_base;
1291
if(DH_generate_key(dh_params)) {
1292
privkey_len = BN_num_bytes(dh_params->priv_key);
1293
pubkey_len = BN_num_bytes(dh_params->pub_key);
1294
*rbuf = (char *)(bin = driver_alloc_binary(1+4+4+pubkey_len+privkey_len));
1295
if (bin==NULL) return -1;
1296
(bin->orig_bytes)[0] = 1;
1297
put_int32(bin->orig_bytes+1, pubkey_len);
1298
BN_bn2bin(dh_params->pub_key, bin->orig_bytes+5);
1299
put_int32(bin->orig_bytes+5+pubkey_len, privkey_len);
1300
BN_bn2bin(dh_params->priv_key, bin->orig_bytes+5+pubkey_len+4);
1302
*rbuf = (char *)(bin = driver_alloc_binary(1));
1303
if (bin==NULL) return -1;
1304
(bin->orig_bytes)[0] = 0;
1310
case DRV_DH_COMPUTE_KEY:
1311
/* buf = <<pubkey_len:32, pubkey:pubkey_len/binary, *
1312
* privkey_len:32, privkey:privkey_len/binary, *
1313
* dh_p_len:32/integer, dh_p:dh_p_len/binary, *
1314
* dh_g_len:32/integer, dh_g:dh_g_len/binary>> */
1317
if(len < 16) return -1;
1318
pubkey_len = get_int32(buf + i + j);
1319
j += pubkey_len; i += 4;
1320
if (len < (16 + j)) return -1;
1321
privkey_len = get_int32(buf + i + j);
1322
j += privkey_len; i += 4;
1323
if (len < (16 + j)) return -1;
1324
dh_p_len = get_int32(buf + i + j);
1325
j += dh_p_len; i += 4;
1326
if (len < (16 + j)) return -1;
1327
dh_g_len = get_int32(buf + i + j);
1328
j += dh_g_len; i += 4;
1329
if(len != (16 + j)) return -1;
1332
BN_bin2bn((unsigned char *)(buf + i), pubkey_len, pubkey);
1333
i += (pubkey_len + 4);
1335
BN_bin2bn((unsigned char *)(buf + i), privkey_len, privkey);
1336
i += (privkey_len + 4);
1338
BN_bin2bn((unsigned char *)(buf + i), dh_p_len, dh_p);
1339
i += (dh_p_len + 4);
1341
BN_bin2bn((unsigned char *)(buf + i), dh_g_len, dh_g);
1342
/* i += (dsa_g_len + 4); */
1344
dh_params = DH_new();
1345
dh_params->p = dh_p;
1346
dh_params->g = dh_g;
1347
dh_params->priv_key = privkey;
1349
klen = DH_size(dh_params);
1350
*rbuf = (char *)(bin = driver_alloc_binary(1+klen));
1351
if (bin==NULL) return -1;
1352
i = DH_compute_key(&bin->orig_bytes[1],pubkey, dh_params);
1354
(bin->orig_bytes)[0] = 1;
1356
(bin->orig_bytes)[0] = 0;
1363
*rbuf = (char*) (bin = driver_alloc_binary(MD4_LEN));
1364
MD4((unsigned char *)buf, len, (unsigned char *)bin->orig_bytes);
1369
*rbuf = (char*) (bin = driver_alloc_binary(MD4_CTX_LEN));
1370
MD4_Init((MD4_CTX *) bin->orig_bytes);
1374
case DRV_MD4_UPDATE:
1375
if (len < MD4_CTX_LEN)
1377
*rbuf = (char*) (bin = driver_alloc_binary(MD4_CTX_LEN));
1378
memcpy(bin->orig_bytes, buf, MD4_CTX_LEN);
1379
MD4_Update((MD4_CTX *) bin->orig_bytes, buf + MD4_CTX_LEN, len - MD4_CTX_LEN);
1384
if (len != MD4_CTX_LEN)
1386
memcpy(&md4_ctx, buf, MD4_CTX_LEN); /* XXX Use buf only? */
1387
*rbuf = (char *) (bin = driver_alloc_binary(MD4_LEN));
1388
MD4_Final((unsigned char *)bin->orig_bytes, &md4_ctx);
1392
#if SSL_VERSION_0_9_8
1394
*rbuf = (char *)(bin = driver_alloc_binary(SHA256_LEN));
1395
SHA256(buf, len, bin->orig_bytes);
1399
case DRV_SHA256_INIT:
1400
*rbuf = (char *)(bin = driver_alloc_binary(SHA256_CTX_LEN));
1401
SHA256_Init((SHA256_CTX *)bin->orig_bytes);
1402
return SHA256_CTX_LEN;
1405
case DRV_SHA256_UPDATE:
1406
if (len < SHA256_CTX_LEN)
1408
*rbuf = (char *)(bin = driver_alloc_binary(SHA256_CTX_LEN));
1409
memcpy(bin->orig_bytes, buf, SHA256_CTX_LEN);
1410
SHA256_Update((SHA256_CTX *)bin->orig_bytes, buf + SHA256_CTX_LEN,
1411
len - SHA256_CTX_LEN);
1412
return SHA256_CTX_LEN;
1415
case DRV_SHA256_FINAL:
1416
if (len != SHA256_CTX_LEN)
1418
memcpy(&sha256_ctx, buf, SHA256_CTX_LEN); /* XXX Use buf only? */
1419
*rbuf = (char *)(bin = driver_alloc_binary(SHA256_LEN));
1420
SHA256_Final(bin->orig_bytes, &sha256_ctx);
1425
*rbuf = (char *)(bin = driver_alloc_binary(SHA512_LEN));
1426
SHA512(buf, len, bin->orig_bytes);
1430
case DRV_SHA512_INIT:
1431
*rbuf = (char *)(bin = driver_alloc_binary(SHA512_CTX_LEN));
1432
SHA512_Init((SHA512_CTX *)bin->orig_bytes);
1433
return SHA512_CTX_LEN;
1436
case DRV_SHA512_UPDATE:
1437
if (len < SHA512_CTX_LEN)
1439
*rbuf = (char *)(bin = driver_alloc_binary(SHA512_CTX_LEN));
1440
memcpy(bin->orig_bytes, buf, SHA512_CTX_LEN);
1441
SHA512_Update((SHA512_CTX *)bin->orig_bytes, buf + SHA512_CTX_LEN,
1442
len - SHA512_CTX_LEN);
1443
return SHA512_CTX_LEN;
1446
case DRV_SHA512_FINAL:
1447
if (len != SHA512_CTX_LEN)
1449
memcpy(&sha512_ctx, buf, SHA512_CTX_LEN); /* XXX Use buf only? */
1450
*rbuf = (char *)(bin = driver_alloc_binary(SHA512_LEN));
1451
SHA512_Final(bin->orig_bytes, &sha512_ctx);
788
1456
case DRV_INFO_LIB:
789
{/* <<DrvVer:8, NameSize:8, Name:NameSize/binary, VerNum:32, VerStr/binary>> */
790
static const char libname[] = "OpenSSL";
791
unsigned name_sz = strlen(libname);
792
const char* ver = SSLeay_version(SSLEAY_VERSION);
793
unsigned ver_sz = strlen(ver);
794
*rbuf = (char*)(bin = driver_alloc_binary(1+1+name_sz+4+ver_sz));
796
*p++ = 0; /* "driver version" for future use */
798
memcpy(p, libname, name_sz);
800
put_int32(p,SSLeay()); /* OPENSSL_VERSION_NUMBER */
802
memcpy(p, ver, ver_sz);
804
return bin->orig_size;
1457
{/* <<DrvVer:8, NameSize:8, Name:NameSize/binary, VerNum:32, VerStr/binary>> */
1458
static const char libname[] = "OpenSSL";
1459
unsigned name_sz = strlen(libname);
1460
const char* ver = SSLeay_version(SSLEAY_VERSION);
1461
unsigned ver_sz = strlen(ver);
1462
*rbuf = (char*)(bin = driver_alloc_binary(1+1+name_sz+4+ver_sz));
1463
if (bin==NULL) return -1;
1464
p = bin->orig_bytes;
1465
*p++ = 0; /* "driver version" for future use */
1467
memcpy(p, libname, name_sz);
1469
put_int32(p,SSLeay()); /* OPENSSL_VERSION_NUMBER */
1471
memcpy(p, ver, ver_sz);
1473
return bin->orig_size;