Int foo()
{
}
_start()
{
        foo();
        bar();
        __asm__("leave");
}

nick@ubuntu-14:~/Documents/staroceans/practice$ objdump -S  nomain.o
nomain.o:     file format elf32-i386
Disassembly of section .text:
00000000 <foo>:
   0:   55                      push   %ebp
   1:   89 e5                   mov    %esp,%ebp
   3:   5d                      pop    %ebp
   4:   c3                      ret    
00000005 <_start>:
   5:   55                      push   %ebp
   6:   89 e5                   mov    %esp,%ebp
   8:   53                      push   %ebx
   9:   83 ec 04                sub    $0x4,%esp
   c:   e8 fc ff ff ff          call   d
<foo+0xd>
  11:   81 c3 02 00 00 00       add    $0x2,%ebx
  17:   e8 fc ff ff ff          call   18
<foo+0x18>
  1c:   c9                      leave  
  1d:   83 c4 04                add    $0x4,%esp
  20:   5b                      pop    %ebx
  21:   5d                      pop    %ebp
  22:   c3                      ret    
Disassembly of section
.text.__x86.get_pc_thunk.bx:
00000023 <__x86.get_pc_thunk.bx>:
  23:   8b 1c 24                mov  (%esp),%ebx
  26:   c3                      ret    

    ; add xx + yy + zz and store it in sum
    ;
    mov     eax, DWORD PTR [ebp-8]
    mov     edx, DWORD PTR [ebp-4]
    lea     eax, [edx+eax]
    add     eax, DWORD PTR [ebp-12]
    mov     DWORD PTR [ebp-16],eax

00000556 <ml_func>:
 556:   55                      push   ebp
 557:   89 e5                   mov    ebp,esp
 559:   53                      push   ebx
 55a:   83 ec 24                sub    esp,0x24
 55d:   e8 be fe ff ff          call   420 <__x86.get_pc_thunk.bx>
 562:   81 c3 9e 1a 00 00       add    ebx,0x1a9e
 568:   8b 45 08                mov    eax,DWORD PTR [ebp+0x8]
 56b:   89 04 24                mov    DWORD PTR [esp],eax
 56e:   e8 9d fe ff ff          call   410 <ml_util_func@plt>

00000477 <ml_func>:
 477:   55                      push   ebp
 478:   89 e5                   mov    ebp,esp
 47a:   53                      push   ebx
 47b:   83 ec 24                sub    esp,0x24
 47e:   e8 e4 ff ff ff          call   467 <__i686.get_pc_thunk.bx>
 483:   81 c3 71 1b 00 00       add    ebx,0x1b71
 489:   8b 45 08                mov    eax,DWORD PTR [ebp+0x8]
 48c:   89 04 24                mov    DWORD PTR [esp],eax
 48f:   e8 0c ff ff ff          call   3a0 <ml_util_func@plt>

0000054b <ml_util_func>:
 54b:   55                      push   ebp
 54c:   89 e5                   mov    ebp,esp
 54e:   8b 45 08                mov    eax,DWORD PTR [ebp+0x8]
 551:   83 c0 01                add    eax,0x1
 554:   5d                      pop    ebp
 555:   c3                      ret

#define _GNU_SOURCE
#include <link.h>
#include <stdlib.h>
#include <stdio.h>

char* typeName[]=
{
"unused",       /* Program header table entry unused */
"Loadable program segment",       /* Loadable program segment */
"Dynamic linking information",       /* Dynamic linking information */
"Program interpreter",       /* Program interpreter */
"Auxiliary information",       /* Auxiliary information */
"Reserved",       /* Reserved */
"Entry for header table itself",       /* Entry for header table itself */
"Thread-local storage segment",       /* Thread-local storage segment */
"Number of defined types",       /* Number of defined types */
"Start of OS-specific",  /* Start of OS-specific */
"GCC .eh_frame_hdr segment",  /* GCC .eh_frame_hdr segment */
"Indicates stack executability",  /* Indicates stack executability */
"Read-only after relocation",  /* Read-only after relocation */
"unknown"
};

int type2Number(int in)
{
    if (in < 8)
    {
        return in;
    }
    switch (in)
    {
        case 0x60000000:
            return 9;
        case 0x6474e550:
            return 10;
        case 0x6474e551:
            return 11;
        case 0x6474e552:
            return 12;
    }
    return 13;
}

char*flagName[] =
{
"executable",    /* Segment is executable */
"writable",    /* Segment is writable */
"readable",    /* Segment is readable */
"OS-specific",  /* OS-specific */
"Processor-specific",  /* Processor-specific */
"PF_PARISC_SBP(PF_HP_SBP)",
"PF_HP_PAGE_SIZE",
"PF_HP_FAR_SHARED",
"PF_HP_NEAR_SHARED",
"PF_HP_CODE",
"PF_HP_MODIFY",
"PF_HP_LAZYSWAP",
"executable|writable",
"executable|readable",
"readable|writable",
"readable|writable|executable",
"unknown"
};
int flag2Number(int in)
{
    switch (in)
    {
        case PF_X:
            return 0;
        case PF_W:
            return 1;
        case PF_R:
            return 2;
        case 0x0ff00000:
            return 3;
        case 0xf0000000:
            return 4;
        case 0x08000000:
            return 5;
        case 0x00100000:
            return 6;
        case 0x00200000:
            return 7;
        case 0x00400000:
            return 8;
        case 0x01000000:
            return 9;
        case 0x02000000:
            return 10;
        case 0x04000000:
            return 11;
        case (PF_X|PF_W):
            return 12;
        case (PF_X|PF_R):
            return 13;
        case (PF_W|PF_R):
            return 14;
        case (PF_X|PF_W|PF_R):
            return 15;
    }
    return 12;
}

static int header_handler(struct dl_phdr_info* info, size_t size, void* data)
{
    printf("name=%s (%d segments) address=%p\n",
            info->dlpi_name, info->dlpi_phnum, (void*)info->dlpi_addr);
    for (int j = 0; j < info->dlpi_phnum; j++) {
         printf("\t\t header %2d: address=%10p\n", j,
             (void*) (info->dlpi_addr + info->dlpi_phdr[j].p_vaddr));
         int typeNumber=type2Number(info->dlpi_phdr[j].p_type);
         int flagNumber=flag2Number(info->dlpi_phdr[j].p_flags);
         printf("\t\t\t type=%s, flags=%s\n",
                 typeName[typeNumber], flagName[flagNumber]);
    }
    printf("\n");
    return 0;
}
extern int ml_func(int, int);
int main(int argc, const char* argv[])
{
    dl_iterate_phdr(header_handler, NULL);

    int t = ml_func(argc, argc);
    return t;
}

name= (9 segments) address=(nil)
		 header  0: address= 0x8048034
			 type=Entry for header table itself, flags=executable|readable
		 header  1: address= 0x8048154
			 type=Program interpreter, flags=readable
		 header  2: address= 0x8048000
			 type=Loadable program segment, flags=executable|readable
		 header  3: address= 0x8049f00
			 type=Loadable program segment, flags=readable|writable
		 header  4: address= 0x8049f0c
			 type=Dynamic linking information, flags=readable|writable
		 header  5: address= 0x8048168
			 type=Auxiliary information, flags=readable
		 header  6: address= 0x8048bd0
			 type=GCC .eh_frame_hdr segment, flags=readable
		 header  7: address=     (nil)
			 type=Indicates stack executability, flags=readable|writable
		 header  8: address= 0x8049f00
			 type=Read-only after relocation, flags=readable

name= (4 segments) address=0xf776e000
		 header  0: address=0xf776e000
			 type=Loadable program segment, flags=executable|readable
		 header  1: address=0xf776e2bc
			 type=Dynamic linking information, flags=readable
		 header  2: address=0xf776e558
			 type=Auxiliary information, flags=readable
		 header  3: address=0xf776e5b8
			 type=GCC .eh_frame_hdr segment, flags=readable

name=/tmp/libfunc.so (7 segments) address=0xf7767000
		 header  0: address=0xf7767000
			 type=Loadable program segment, flags=executable|readable
		 header  1: address=0xf7768ef8
			 type=Loadable program segment, flags=readable|writable
		 header  2: address=0xf7768f04
			 type=Dynamic linking information, flags=readable|writable
		 header  3: address=0xf7767114
			 type=Auxiliary information, flags=readable
		 header  4: address=0xf77675a0
			 type=GCC .eh_frame_hdr segment, flags=readable
		 header  5: address=0xf7767000
			 type=Indicates stack executability, flags=readable|writable
		 header  6: address=0xf7768ef8
			 type=Read-only after relocation, flags=readable

name=/lib32/libc.so.6 (10 segments) address=0xf759a000
		 header  0: address=0xf759a034
			 type=Entry for header table itself, flags=executable|readable
		 header  1: address=0xf7704cb4
			 type=Program interpreter, flags=readable
		 header  2: address=0xf759a000
			 type=Loadable program segment, flags=executable|readable
		 header  3: address=0xf77421dc
			 type=Loadable program segment, flags=readable|writable
		 header  4: address=0xf7743da8
			 type=Dynamic linking information, flags=readable|writable
		 header  5: address=0xf759a174
			 type=Auxiliary information, flags=readable
		 header  6: address=0xf77421dc
			 type=Thread-local storage segment, flags=readable
		 header  7: address=0xf7704cc8
			 type=GCC .eh_frame_hdr segment, flags=readable
		 header  8: address=0xf759a000
			 type=Indicates stack executability, flags=readable|writable
		 header  9: address=0xf77421dc
			 type=Read-only after relocation, flags=readable

name=/lib/ld-linux.so.2 (7 segments) address=0xf7770000
		 header  0: address=0xf7770000
			 type=Loadable program segment, flags=executable|readable
		 header  1: address=0xf7790cc0
			 type=Loadable program segment, flags=readable|writable
		 header  2: address=0xf7790f30
			 type=Dynamic linking information, flags=readable|writable
		 header  3: address=0xf7770114
			 type=Auxiliary information, flags=readable
		 header  4: address=0xf778c8c0
			 type=GCC .eh_frame_hdr segment, flags=readable
		 header  5: address=0xf7770000
			 type=Indicates stack executability, flags=readable|writable
		 header  6: address=0xf7790cc0
			 type=Read-only after relocation, flags=readable

int myglob = 42;
int ml_util_func(int a)
{
    return a + 1;
}
int ml_func(int a, int b)
{
    int c = b + ml_util_func(a);
    myglob += c;
    return b + myglob;
}

00000556 <ml_func>:
 556:   55                      push   ebp
 557:   89 e5                   mov    ebp,esp
 559:   83 ec 14                sub    esp,0x14
 55c:   8b 45 08                mov    eax,DWORD PTR [ebp+0x8]
 55f:   89 04 24                mov    DWORD PTR [esp],eax
 562:   e8 fc ff ff ff          call   563 <ml_func+0xd>
 567:   8b 55 0c                mov    edx,DWORD PTR [ebp+0xc]
 56a:   01 d0                   add    eax,edx
 56c:   89 45 fc                mov    DWORD PTR [ebp-0x4],eax
 56f:   8b 15 00 00 00 00       mov    edx,DWORD PTR ds:0x0
 575:   8b 45 fc                mov    eax,DWORD PTR [ebp-0x4]
 578:   01 d0                   add    eax,edx
 57a:   a3 00 00 00 00          mov    ds:0x0,eax
 57f:   8b 15 00 00 00 00       mov    edx,DWORD PTR ds:0x0
 585:   8b 45 0c                mov    eax,DWORD PTR [ebp+0xc]
 588:   01 d0                   add    eax,edx
 58a:   c9                      leave  
 58b:   c3                      ret  

00000556 <ml_func>:
 556:   55                      push   ebp
 557:   89 e5                   mov    ebp,esp
 559:   53                      push   ebx
 55a:   83 ec 24                sub    esp,0x24
 55d:   e8 be fe ff ff          call   420 <__x86.get_pc_thunk.bx>
 562:   81 c3 9e 1a 00 00       add    ebx,0x1a9e
 568:   8b 45 08                mov    eax,DWORD PTR [ebp+0x8]
 56b:   89 04 24                mov    DWORD PTR [esp],eax
 56e:   e8 9d fe ff ff          call   410 <ml_util_func@plt>
 573:   8b 55 0c                mov    edx,DWORD PTR [ebp+0xc]
 576:   01 d0                   add    eax,edx
 578:   89 45 f4                mov    DWORD PTR [ebp-0xc],eax
 57b:   8b 83 ec ff ff ff       mov    eax,DWORD PTR [ebx-0x14]
 581:   8b 10                   mov    edx,DWORD PTR [eax]
 583:   8b 45 f4                mov    eax,DWORD PTR [ebp-0xc]
 586:   01 c2                   add    edx,eax
 588:   8b 83 ec ff ff ff       mov    eax,DWORD PTR [ebx-0x14]
 58e:   89 10                   mov    DWORD PTR [eax],edx
 590:   8b 83 ec ff ff ff       mov    eax,DWORD PTR [ebx-0x14]
 596:   8b 10                   mov    edx,DWORD PTR [eax]
 598:   8b 45 0c                mov    eax,DWORD PTR [ebp+0xc]
 59b:   01 d0                   add    eax,edx
 59d:   83 c4 24                add    esp,0x24
 5a0:   5b                      pop    ebx
 5a1:   5d                      pop    ebp
 5a2:   c3                      ret    

/* demos/sign/sign.c */
/* sign-it.cpp  -  Simple test app using SSLeay envelopes to sign data
   29.9.1996, Sampo Kellomaki <sampo@iki.fi> */

/* converted to C - eay :-) */

/* reformated a bit and converted to use the more common functions: this was
 * initially written at the dawn of time :-) - Steve.
 */

#include <stdio.h>
#include <openssl/rsa.h>
#include <openssl/evp.h>
#include <openssl/objects.h>
#include <openssl/x509.h>
#include <openssl/err.h>
#include <openssl/pem.h>
#include <openssl/ssl.h>

int main ()
{
  int err;
  int sig_len;
  unsigned char sig_buf [4096];
  static char certfile[] = "cert.pem";
  static char keyfile[]  = "key.pem";
  static char data[]     = "I owe you...";
  EVP_MD_CTX     md_ctx;
  EVP_PKEY *      pkey;
  FILE *          fp;
  X509 *	x509;

  /* Just load the crypto library error strings,
   * SSL_load_error_strings() loads the crypto AND the SSL ones */
  /* SSL_load_error_strings();*/
  ERR_load_crypto_strings();
  
  /* Read private key */
  
  fp = fopen (keyfile, "r");
  if (fp == NULL) exit (1);
  pkey = PEM_read_PrivateKey(fp, NULL, NULL, NULL);
  fclose (fp);

  if (pkey == NULL) { 
	ERR_print_errors_fp (stderr);
	exit (1);
  }
  
  /* Do the signature */
  
  EVP_SignInit   (&md_ctx, EVP_sha1());
  EVP_SignUpdate (&md_ctx, data, strlen(data));
  sig_len = sizeof(sig_buf);
  err = EVP_SignFinal (&md_ctx, sig_buf, &sig_len, pkey);

  if (err != 1) {
	ERR_print_errors_fp(stderr);
	exit (1);
  }

  EVP_PKEY_free (pkey);
  
  /* Read public key */
  
  fp = fopen (certfile, "r");
  if (fp == NULL) exit (1);
  x509 = PEM_read_X509(fp, NULL, NULL, NULL);
  fclose (fp);

  if (x509 == NULL) {
	ERR_print_errors_fp (stderr);
	exit (1);
  }
  
  /* Get public key - eay */
  pkey=X509_get_pubkey(x509);
  if (pkey == NULL) {
	ERR_print_errors_fp (stderr);
	exit (1);
  }

  /* Verify the signature */
  
  EVP_VerifyInit   (&md_ctx, EVP_sha1());
  EVP_VerifyUpdate (&md_ctx, data, strlen((char*)data));
  err = EVP_VerifyFinal (&md_ctx, sig_buf, sig_len, pkey);
  EVP_PKEY_free (pkey);

  if (err != 1) {
	ERR_print_errors_fp (stderr);
	exit (1);
  }
  printf ("Signature Verified Ok.\n");
  return(0);
}

auto eth0
iface eth0 inet static
address 192.168.1.226
netmask 255.255.255.0
network 192.168.1.0
broadcast 192.168.1.255
gateway 192.168.1.1
dns-nameservers 192.168.1.1
dns-nameservers 8.8.8.8

Version definitions:
1 0x01 0x0746be50 libcrypto.so.1.0.0
2 0x00 0x066a2b20 OPENSSL_1.0.0
3 0x00 0x066a2b21 OPENSSL_1.0.1
        OPENSSL_1.0.0 
4 0x00 0x06a2b214 OPENSSL_1.0.1d
        OPENSSL_1.0.1 

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <openssl/bn.h>

void callback(type,
              num)
    int type, num;
{
//    if (type == 0)
//        fprintf(stderr, ".");
//    else if (type == 1)
//        fprintf(stderr, "+");
//    else if (type == 2)
//        fprintf(stderr, "*");
//    fflush(stderr);
}

int newCallback(int a, int b, BN_GENCB* cb)
{
//    switch (a)
//    {
//    case 0:
//        //printf("0(%d)", b);
//        printf("0");
//        break;
//    case 1:
//        //printf("1[%d]", b);
//        printf("1");
//        break;
//    case 2:
//        //printf("2{%d}", b);
//        printf("2");
//        break;
//    default:
//        printf("%d", a);
//        break;
//    }
    return 1;
}
char buff[20];
time_t now;

int oldFunc(int argc, char* argv[])
{
    BIGNUM* rand = BN_new();;
    int num=256;

    if (argc >= 2)
    {
        num=atoi(argv[1]);
        if (num == 0)
            num=256;
    }

    fprintf(stderr, "generate a strong prime\n");

    now = time(NULL);
    strftime(buff, 20, "%Y-%m-%d %H:%M:%S", localtime(&now));
    printf("\ntime:[%s]\n", buff);
    rand = BN_generate_prime(rand, num, 1, NULL, NULL, callback, NULL);
    BN_print_fp(stdout, rand);
    now = time(NULL);
    strftime(buff, 20, "%Y-%m-%d %H:%M:%S", localtime(&now));
    printf("\ntime:[%s]\n", buff);

    fprintf(stdout, "\n");

    fprintf(stdout, "\n");

    return 0;
}

int newFunc(int argc, char *argv[])
{
    int num = 256;
    if (argc >= 2)
    {
        num=atoi(argv[1]);
        if (num == 0)
        {
            num=256;
        }
    }
    BIGNUM *bn = BN_new();

    BN_GENCB cb;
    cb.ver = 2;
    cb.cb.cb_2 = newCallback;
    cb.arg = NULL;
    now = time(NULL);
    strftime(buff, 20, "%Y-%m-%d %H:%M:%S", localtime(&now));
    printf("\ntime:[%s]\n", buff);
    if (!BN_generate_prime_ex(bn, num, 1, NULL, NULL, &cb))
    {
        printf("Failed to generate prime.\n");
    }
    else
    {
        printf("bits:%d\n", num);
        BN_print_fp(stdout, bn);
        printf("\n");
    }
    now = time(NULL);
    strftime(buff, 20, "%Y-%m-%d %H:%M:%S", localtime(&now));
    printf("\ntime:[%s]\n", buff);
    BN_free(bn);
    return 0;
}

int main(int argc, char* argv[])
{
    oldFunc(argc, argv);
    newFunc(argc, argv);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <openssl/evp.h>
#include <openssl/rsa.h>
#include <openssl/err.h>
#include <openssl/bio.h>

int printBIO(const char* strCtx, BIO* bio)
{
    char buffer[2048+1];
    int num = 0;
    printf("*******%s begins*****\n", strCtx);
    while ((num = BIO_gets(bio, buffer, 2048))>0)
    {
        buffer[num] = '\0';
        printf("%s", buffer);
    }
    printf("********%s ends*****\n", strCtx);
    if (num < 0)
    {
        printf("BIO_gets error: %s\n", ERR_error_string(ERR_get_error(), NULL));
        return -1;
    }
    return 0;
}

int main(void)
{
    EVP_PKEY_CTX *ctx = NULL;
    BIO* bio = NULL;
    EVP_PKEY *pkey = NULL;
    pkey = EVP_PKEY_new();
    if (pkey == NULL)
    {
        printf("EVP_PKEY_new error: %s\n", ERR_error_string(ERR_get_error(), NULL));
        goto clear;
    }
    ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL);
    if (!ctx)
    {
        printf("EVP_PKEY_CTX_new_id error: %s\n", ERR_error_string(ERR_get_error(), NULL));
        goto clear;
    }

    if (EVP_PKEY_keygen_init(ctx) <= 0)
    {
        printf("EVP_PKEY_CTX_new_id error: %s\n", ERR_error_string(ERR_get_error(), NULL));
        goto clear;
    }

    if (EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, 2048) <= 0)
    {
        printf("EVP_PKEY_CTX_set_rsa_keygen_bits error: %s\n", ERR_error_string(ERR_get_error(), NULL));
        goto clear;
    }

    /* Generate key */
    if (EVP_PKEY_keygen(ctx, &pkey) <= 0)
    {
        printf("EVP_PKEY_keygen error: %s\n", ERR_error_string(ERR_get_error(), NULL));
        goto clear;
    }
    bio = BIO_new(BIO_s_mem());
    if (bio == NULL)
    {
        printf("BIO_new error: %s\n", ERR_error_string(ERR_get_error(), NULL));
        goto clear;
    }
    if (EVP_PKEY_print_public(bio, pkey, 1, NULL)!= 1)
    {
        printf("EVP_PKEY_print_public error: %s\n", ERR_error_string(ERR_get_error(), NULL));
        goto clear;
    }
    if (printBIO("public key", bio) < 0)
    {
        printf("print public key failed\n");
        goto clear;
    }

    if (EVP_PKEY_print_private(bio, pkey, 1, NULL)!= 1)
    {
        printf("EVP_PKEY_print_private error: %s\n", ERR_error_string(ERR_get_error(), NULL));
        goto clear;
    }
    if (printBIO("private key", bio) < 0)
    {
        printf("print private key failed\n");
        goto clear;
    }

    if (EVP_PKEY_print_params(bio, pkey, 1, NULL)!= 1)
    {
        printf("EVP_PKEY_print_params error: %s\n", ERR_error_string(ERR_get_error(), NULL));
        goto clear;
    }
    if (printBIO("key params", bio) < 0)
    {
        printf("print key params failed\n");
        goto clear;
    }
clear:
    if (pkey)
    {
        EVP_PKEY_free(pkey);
    }
    if (ctx)
    {
        EVP_PKEY_CTX_free(ctx);
    }
    if (bio)
    {
        BIO_free(bio);
    }
    return 0;
}
*******public key begins*****
 Public-Key: (2048 bit)
 Modulus:
     00:c0:06:57:34:eb:12:9a:87:b1:a9:53:6d:b8:a6:
     c1:99:6d:35:53:b3:c0:01:c0:5b:1b:1f:8e:ca:ec:
     28:9f:29:d3:62:b0:fa:f9:38:72:f7:14:18:1b:fa:
     0c:28:45:2b:c2:39:35:2e:9f:c3:f2:47:a8:ba:5b:
     53:c6:db:be:d1:6d:67:d3:15:6b:d0:6d:db:5a:1f:
     2b:70:1e:8d:30:eb:12:29:9f:83:e0:0f:3b:a3:76:
     2e:12:61:16:d8:34:54:cd:a6:7e:71:3d:68:67:13:
     b1:37:95:66:24:c3:3e:2e:6a:b2:f1:a2:9c:a7:24:
     44:58:21:28:b5:b1:8c:32:a6:77:44:be:11:9b:df:
     74:77:36:2f:06:2b:8e:52:47:67:10:26:ef:d1:2b:
     42:f7:6c:b0:bb:98:36:0e:bd:1e:a2:58:68:20:7c:
     35:e9:55:c5:6c:bb:c8:e1:6e:99:d4:ec:f3:59:14:
     ea:3a:03:36:20:95:90:e9:ad:8b:09:49:9b:65:b2:
     65:14:00:05:4a:c1:bb:15:6d:92:78:2c:a1:44:f9:
     9a:59:28:ab:6c:73:5e:65:cb:81:20:8c:62:2f:3a:
     3b:7a:da:a1:84:e3:d4:84:e5:9f:38:e5:ae:22:3f:
     92:03:42:ce:72:49:6c:f9:7f:9a:98:ce:82:94:22:
     c0:2f
 Exponent: 65537 (0x10001)
********public key ends*****
*******private key begins*****
 Private-Key: (2048 bit)
 modulus:
     00:c0:06:57:34:eb:12:9a:87:b1:a9:53:6d:b8:a6:
     c1:99:6d:35:53:b3:c0:01:c0:5b:1b:1f:8e:ca:ec:
     28:9f:29:d3:62:b0:fa:f9:38:72:f7:14:18:1b:fa:
     0c:28:45:2b:c2:39:35:2e:9f:c3:f2:47:a8:ba:5b:
     53:c6:db:be:d1:6d:67:d3:15:6b:d0:6d:db:5a:1f:
     2b:70:1e:8d:30:eb:12:29:9f:83:e0:0f:3b:a3:76:
     2e:12:61:16:d8:34:54:cd:a6:7e:71:3d:68:67:13:
     b1:37:95:66:24:c3:3e:2e:6a:b2:f1:a2:9c:a7:24:
     44:58:21:28:b5:b1:8c:32:a6:77:44:be:11:9b:df:
     74:77:36:2f:06:2b:8e:52:47:67:10:26:ef:d1:2b:
     42:f7:6c:b0:bb:98:36:0e:bd:1e:a2:58:68:20:7c:
     35:e9:55:c5:6c:bb:c8:e1:6e:99:d4:ec:f3:59:14:
     ea:3a:03:36:20:95:90:e9:ad:8b:09:49:9b:65:b2:
     65:14:00:05:4a:c1:bb:15:6d:92:78:2c:a1:44:f9:
     9a:59:28:ab:6c:73:5e:65:cb:81:20:8c:62:2f:3a:
     3b:7a:da:a1:84:e3:d4:84:e5:9f:38:e5:ae:22:3f:
     92:03:42:ce:72:49:6c:f9:7f:9a:98:ce:82:94:22:
     c0:2f
 publicExponent: 65537 (0x10001)
 privateExponent:
     64:9f:6d:f7:36:ef:6a:b6:8c:6c:74:61:5c:8f:55:
     87:b6:68:69:52:19:dd:51:14:ec:a3:9e:c9:ca:f2:
     86:64:fe:76:0a:d3:98:e0:f1:ad:73:84:26:b4:e2:
     c5:ff:69:2c:bf:99:94:b2:f7:94:ef:e4:04:b3:72:
     b5:13:d5:6c:1c:ee:78:f8:12:a5:07:cc:17:ef:99:
     6d:89:34:e7:5b:67:0b:14:a1:a0:39:9b:40:ce:de:
     d9:96:b2:c7:dc:b4:4b:87:61:5e:a9:95:19:de:81:
     d0:e4:a2:bf:c4:e7:c2:9e:fa:e2:10:1a:12:a3:b8:
     84:8d:eb:ad:3a:3a:83:17:39:59:4d:9b:8c:76:73:
     0d:8c:dc:e0:dd:21:0d:af:45:4a:29:57:e1:04:df:
     9e:9c:26:dc:72:7b:5b:e5:5c:a7:0f:d7:db:f0:fe:
     2b:3d:b5:f8:00:5c:ee:1f:b2:ca:04:8d:3a:94:26:
     86:08:1a:b1:1e:9b:df:81:82:ae:d9:db:6f:74:9a:
     dc:7c:f9:f0:f0:62:c4:2a:c6:89:84:e5:9d:5e:da:
     54:d4:c5:da:2d:fd:b2:6a:ab:d7:d4:ee:8d:bf:d7:
     e5:43:ef:e8:d8:88:0b:0d:13:58:26:45:d9:3a:1f:
     ee:d9:74:dd:f2:75:cb:1c:1b:35:57:c6:3d:d4:2a:
     a1
 prime1:
     00:ff:70:89:15:d8:db:20:f9:38:05:bc:83:7a:c0:
     da:29:ed:96:6e:21:0b:65:1e:cd:dd:a6:76:3e:13:
     d0:39:54:9b:bb:0c:d4:c6:65:34:ee:b2:66:5b:6a:
     c3:c9:f1:ab:96:20:8f:4a:e1:b1:67:bc:79:aa:9d:
     33:9f:2d:23:1f:4a:b1:7b:b1:1b:43:7a:f8:35:b7:
     b1:c3:70:85:b2:4e:00:24:d0:3c:67:58:7f:19:19:
     51:95:da:99:23:b9:c9:db:6c:da:8c:91:08:8f:02:
     af:5a:82:e6:84:c1:73:95:b9:3f:0f:e6:79:76:18:
     e3:69:c8:75:ac:ba:8e:dc:97
 prime2:
     00:c0:72:30:62:9a:41:8f:78:72:85:8f:88:c8:8a:
     66:f8:46:75:d5:97:a3:76:5a:4c:a2:cd:9e:aa:f5:
     4c:a2:e5:7d:96:ff:94:93:38:99:d4:7e:61:f9:51:
     e5:b5:cc:a0:eb:ae:70:d4:ce:8a:c8:50:63:c8:60:
     34:8c:8b:81:19:43:cf:0d:d8:60:68:6f:06:b9:59:
     66:08:65:a0:78:2f:12:af:e7:c7:9d:67:9b:e4:54:
     17:88:96:77:96:48:20:c3:ba:1f:d4:36:64:37:b8:
     97:56:47:82:91:7d:8a:92:5a:bb:64:cc:9c:7c:6b:
     52:a8:66:e3:ab:73:bb:74:29
 exponent1:
     1d:c3:2a:f5:d4:b2:93:80:f6:3a:14:e0:ec:e8:93:
     82:d7:1f:f3:ec:fd:ba:e6:7f:ee:17:7b:27:78:7f:
     86:6e:89:46:9e:14:1c:99:a6:35:39:ac:1b:72:b1:
     25:52:77:3f:a2:c3:8f:62:04:9d:a5:a4:37:70:e1:
     96:e6:57:75:49:ea:ac:12:d2:ae:66:21:8d:80:bd:
     c1:9b:d6:b8:13:c6:88:83:8a:c6:2f:d5:7f:43:27:
     f2:61:e9:fd:f3:a3:c5:61:45:85:a3:50:6f:f9:4c:
     1d:2b:ab:58:44:82:07:2b:f2:61:13:e5:8b:11:13:
     4e:3c:01:1a:03:12:aa:39
 exponent2:
     3c:38:7f:63:9b:99:c0:67:94:8e:ae:e7:c2:b9:6c:
     97:6c:95:1b:0d:a4:9d:38:8c:9a:b5:75:5d:51:fd:
     75:4c:13:0c:d9:55:88:ec:41:56:f9:65:77:3b:65:
     82:8a:52:20:ee:29:68:ae:69:47:5d:c0:9b:c7:5f:
     2a:4b:cd:4e:36:a5:e8:53:39:77:f4:a6:4a:01:eb:
     a7:dd:05:66:16:74:e6:8e:c5:2c:40:6b:cb:fb:74:
     91:cd:64:06:a6:f3:79:cc:18:81:b3:b3:90:ac:36:
     cf:4c:f9:52:c5:d2:43:12:19:69:e5:8d:62:71:c3:
     1f:e7:72:7f:08:6c:34:61
 coefficient:
     00:db:d4:8c:80:bc:17:3f:f5:68:51:da:d3:a9:8d:
     01:50:e4:5d:a5:c1:bc:55:20:83:64:b5:2b:0e:cb:
     a6:b5:d6:8f:0c:7c:d8:c4:2e:a8:72:ed:dc:a3:d3:
     a7:73:be:05:33:27:bd:59:7e:01:e1:9f:88:08:73:
     ee:ee:9a:1e:cf:19:28:1e:dc:b8:0d:ef:1b:50:91:
     d3:0b:f9:93:6a:52:99:9f:8d:74:80:9b:51:87:0e:
     c2:b3:a9:7f:d5:79:1c:4b:88:bc:5e:16:42:f2:92:
     e9:d8:78:de:68:1f:ef:43:24:6a:ad:3d:30:c3:76:
     f5:c1:4f:94:9b:df:83:ce:9e
********private key ends*****
*******key params begins*****
 Parameters algorithm "rsaEncryption" unsupported
********key params ends*****

int signTest(EVP_PKEY *pkey, const unsigned char* msg, size_t msgSize, unsigned char** sig, size_t* sigSize)
{
    if (pkey == NULL || msg == NULL || msgSize == 0 || sig == NULL || sigSize== NULL)
    {
        printf("invalid parameter!\n");
        return -1;
    }
    int result = 0;
    EVP_PKEY_CTX *ctx = NULL;
    ctx = EVP_PKEY_CTX_new(pkey, NULL); //a very different ctx from key generation
    if (!ctx)
    {
        result = ERR_get_error();
        printf("EVP_PKEY_CTX_new error: %s\n", ERR_error_string(result, NULL));
        goto clear;
    }
    if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) <= 0)
    {
        result = ERR_get_error();
        printf("EVP_PKEY_CTX_set_rsa_padding error: %s\n", ERR_error_string(result, NULL));
        goto clear;
    }
    if (EVP_PKEY_CTX_set_signature_md(ctx, EVP_sha256()) <= 0)
    {
        result = ERR_get_error();
        printf("EVP_PKEY_CTX_set_signature_md error: %s\n", ERR_error_string(result, NULL));
        goto clear;
    }

    /* Determine buffer length */
if (EVP_PKEY_sign(ctx, NULL, sigSize, msg, msgSize) <= 0)
    {
        result = ERR_get_error();
        printf("EVP_PKEY_sign error: %s\n", ERR_error_string(result, NULL));
        goto clear;
    }

    *sig = OPENSSL_malloc(sigSize);
    if (*sig == NULL)
    {
        result = ERR_get_error();
        printf("OPENSSL_malloc error: %s\n", ERR_error_string(result, NULL));
        goto clear;
    }
    if (EVP_PKEY_sign(ctx, *sig, sigSize, msg, msgSize) <= 0)
    {
        OPENSSL_free(*sig);
        result = ERR_get_error();
        printf("OPENSSL_malloc error: %s\n", ERR_error_string(result, NULL));
        goto clear;
    }
clear:
    if (ctx)
    {
        EVP_PKEY_CTX_free(ctx);
    }
    return result;
}

/*
 * digestTest.c
 *
 *  Created on: Feb 7, 2018
 *      Author: nick
 */
/*
 ============================================================================
 Name        : keyGenTest.c
 Author      : Nick Huang
 Version     : 1.0
 Copyright   : Your copyright notice
 Description : Hello World in C, Ansi-style
 ============================================================================
 */
#include <stdio.h>
#include <stdlib.h>
#include <openssl/evp.h>
#include <openssl/rsa.h>
#include <openssl/err.h>
#include <openssl/bio.h>

#define HANDLE_ERR(func)\
    printf("%s: %s\n", #func, ERR_reason_error_string(ERR_get_error())); result = -1; goto clear;

/* Bogus key and IV: we'd normally set these from
 * another source.
 */
unsigned char key[EVP_MAX_KEY_LENGTH] = "01234567890123456789012345678901";
unsigned char iv[EVP_MAX_IV_LENGTH] = "0123456789012345";
#define CIPHER EVP_aes_256_cbc()[1]

const char* StrPrivateKeyFileName="privateKey.pem";
const char* StrPublicKeyFileName="publicKey.pem";
const char* StrPrivateKeyTextFileName="privateKey.txt";
const char* StrPublicKeyTextFileName="publicKey.txt";
const char* StrParamTextFileName="param.txt";

const char* StrCipherFileName="cipher.txt";
const char* StrPlainFileName="plain.txt";


int printBIO(const char* strCtx, BIO* bio)
{
    char buffer[2048+1];
    int num = 0;
    printf("*******%s begins*****\n", strCtx);
    while ((num = BIO_gets(bio, buffer, 2048))>0)
    {
        buffer[num] = '\0';
        printf("%s", buffer);
    }
    printf("********%s ends*****\n", strCtx);
    if (num < 0)
    {
        printf("BIO_gets error: %s\n", ERR_reason_error_string(ERR_get_error()));
        return -1;
    }
    return 0;
}

int printKey(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
{
    int result = 0;
    BIO* bio = NULL;
    bio = BIO_new(BIO_s_mem());
    if (bio == NULL)
    {
        HANDLE_ERR(BIO_new);
    }
    if (EVP_PKEY_print_public(bio, pkey, 1, NULL)!= 1)
    {
        HANDLE_ERR(EVP_PKEY_print_public);
    }
    if (printBIO("public key", bio) < 0)
    {
        HANDLE_ERR(printBIO);
    }

    if (EVP_PKEY_print_private(bio, pkey, 1, NULL)!= 1)
    {
        HANDLE_ERR(EVP_PKEY_print_private);
    }
    if (printBIO("private key", bio) < 0)
    {
        HANDLE_ERR(printBIO);
    }

    if (EVP_PKEY_print_params(bio, pkey, 1, NULL)!= 1)
    {
        HANDLE_ERR(EVP_PKEY_print_params);
    }
    if (printBIO("key params", bio) < 0)
    {
        HANDLE_ERR(printBIO);
    }
clear:
    if (bio)
    {
        BIO_free(bio);
    }
    return result;
}

int printKeyFile(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
{
    int result = 0;
    BIO* bio = NULL;
    bio = BIO_new_file(StrPublicKeyTextFileName, "w+b");
    if (bio == NULL)
    {
        HANDLE_ERR(BIO_new);
    }
    if (EVP_PKEY_print_public(bio, pkey, 1, NULL)!= 1)
    {
        HANDLE_ERR(EVP_PKEY_print_public);
    }
    if (bio)
    {
        BIO_free(bio);
        bio = NULL;
    }
    bio = BIO_new_file(StrPrivateKeyTextFileName, "w+b");
    if (bio == NULL)
    {
        HANDLE_ERR(BIO_new);
    }
    if (EVP_PKEY_print_private(bio, pkey, 1, NULL)!= 1)
    {
        HANDLE_ERR(EVP_PKEY_print_private);
    }

    if (bio)
    {
       BIO_free(bio);
       bio = NULL;
    }
    bio = BIO_new_file(StrParamTextFileName, "w+b");
    if (bio == NULL)
    {
        HANDLE_ERR(BIO_new);
    }

    if (EVP_PKEY_print_params(bio, pkey, 1, NULL)!= 1)
    {
        HANDLE_ERR(EVP_PKEY_print_params);
    }
clear:
    if (bio)
    {
        BIO_free(bio);
    }
    return result;
}
int createKey(unsigned int nBits, EVP_PKEY **ppkey)
{
    int result = 0;
    ERR_load_crypto_strings();
    EVP_PKEY_CTX *ctx = NULL;

    EVP_PKEY *pkey = NULL;
    pkey = EVP_PKEY_new();
    if (pkey == NULL)
    {
        HANDLE_ERR(EVP_PKEY_new);
    }
    ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL);
    if (!ctx)
    {
        HANDLE_ERR(EVP_PKEY_CTX_new_id);
    }

    if (EVP_PKEY_keygen_init(ctx) <= 0)
    {
        HANDLE_ERR(EVP_PKEY_keygen_init);
    }

    if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) <= 0)
    {
        HANDLE_ERR(EVP_PKEY_CTX_set_rsa_padding);
    }

    if (EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, nBits [2]) <= 0)
    {
        HANDLE_ERR(EVP_PKEY_CTX_set_rsa_keygen_bits);
    }
     /* Generate key */
    if (EVP_PKEY_keygen(ctx, &pkey) <= 0)
    {
        HANDLE_ERR(EVP_PKEY_keygen);
    }
    if (printKey(ctx, pkey) != 0)
    {
        HANDLE_ERR(testKey);
    }
    if (printKeyFile(ctx, pkey) != 0)
    {
        HANDLE_ERR(printKeyFile);
    }

clear:
    if (result == 0)
    {
        *ppkey = pkey;
    }
    else
    {
        EVP_PKEY_free(pkey);
    }
    if (ctx)
    {
        EVP_PKEY_CTX_free(ctx);
    }
    return result;
}

int encrypt(EVP_PKEY *pkey)
{
    const unsigned int BufferSize = 1024;
    int toEncrypt = 1;
    int result = 0;
    /* Allow enough space in output buffer for additional block */
    unsigned char inbuf[BufferSize], outbuf[BufferSize + EVP_MAX_BLOCK_LENGTH];
    int inlen, outlen;
    FILE* in = NULL;
    FILE* out = NULL;
    /* Don't set key or IV because we will modify the parameters */
    EVP_CIPHER_CTX ctx;

    in = fopen(__FILE__, "r+b");
    if (in == NULL)
    {
        HANDLE_ERR(fopen);
    }
    out = fopen(StrCipherFileName, "w+b");
    if (out == NULL)
    {
        HANDLE_ERR(fopen);
    }
    EVP_CIPHER_CTX_init(&ctx);
    if (EVP_CipherInit_ex(&ctx, CIPHER, NULL, NULL, NULL, toEncrypt) <= 0)
    {
        HANDLE_ERR(EVP_CipherInit_ex);
    }

    if (EVP_CIPHER_CTX_set_key_length(&ctx, EVP_CIPHER_key_length(CIPHER)) <= 0)
    {
        HANDLE_ERR(EVP_CIPHER_CTX_set_key_length);
    }
    /* We finished modifying parameters so now we can set key and IV */
    if (EVP_CipherInit_ex(&ctx, NULL, NULL, key, iv, toEncrypt) <= 0)
    {
        HANDLE_ERR(EVP_CipherInit_ex);
    }

    printf("Length of the key is %d\n",EVP_CIPHER_key_length(CIPHER));
    printf("Length of the IV is %d\n",EVP_CIPHER_CTX_iv_length(&ctx));

    for(;;)
    {
        inlen = fread(inbuf, 1, BufferSize, in);
        if(inlen <= 0)
        {
            break;
        }
        if(EVP_CipherUpdate(&ctx, outbuf, &outlen, inbuf, inlen) <= 0)
        {
            HANDLE_ERR(EVP_CipherUpdate);
        }
        if (fwrite(outbuf, 1, outlen, out) != outlen)
        {
            HANDLE_ERR(fwrite);
        }
    }
    outlen = EVP_MAX_BLOCK_LENGTH;[3]
    if(EVP_CipherFinal_ex(&ctx, outbuf, &outlen) <= 0)
    {
        HANDLE_ERR(EVP_CipherFinal_ex);
    }
    if (fwrite(outbuf, 1, outlen, out) != outlen)
    {
        HANDLE_ERR(fwrite);
    }
clear:
    EVP_CIPHER_CTX_cleanup(&ctx);
    if (in)
    {
        fclose(in);
    }
    if (out)
    {
        fclose(out);
    }
    return result;
}

int decrypt(EVP_PKEY *pkey)
{
    const unsigned int BufferSize = 1024;
    int toEncrypt = 0;
    int result = 0;
    /* Allow enough space in output buffer for additional block */
    unsigned char inbuf[BufferSize], outbuf[BufferSize + EVP_MAX_BLOCK_LENGTH];
    int inlen, outlen;
    FILE* in = NULL;
    FILE* out = NULL;
    /* Don't set key or IV because we will modify the parameters */
    EVP_CIPHER_CTX ctx;

    in = fopen(StrCipherFileName, "r+b");
    if (in == NULL)
    {
        HANDLE_ERR(fopen);
    }
    out = fopen(StrPlainFileName, "w+b");
    if (out == NULL)
    {
        HANDLE_ERR(fopen);
    }
    EVP_CIPHER_CTX_init(&ctx);
    if (EVP_CipherInit_ex(&ctx, CIPHER, NULL, NULL, NULL, toEncrypt) <= 0)
    {
        HANDLE_ERR(EVP_CipherInit_ex);
    }

    if (EVP_CIPHER_CTX_set_key_length(&ctx, EVP_CIPHER_key_length(CIPHER)) <= 0)
    {
        HANDLE_ERR(EVP_CIPHER_CTX_set_key_length);
    }
    /* We finished modifying parameters so now we can set key and IV */
    if (EVP_CipherInit_ex(&ctx, NULL, NULL, key, iv, toEncrypt) <= 0)
    {
        HANDLE_ERR(EVP_CipherInit_ex);
    }

    printf("Length of the key is %d\n",EVP_CIPHER_key_length(CIPHER));
    printf("Length of the IV is %d\n",EVP_CIPHER_CTX_iv_length(&ctx));

    for(;;)
    {
        inlen = fread(inbuf, 1, BufferSize, in);
        if(inlen <= 0)
        {
            break;
        }
        if(EVP_CipherUpdate(&ctx, outbuf, &outlen, inbuf, inlen) <= 0)
        {
            HANDLE_ERR(EVP_CipherUpdate);
        }
        if (fwrite(outbuf, 1, outlen, out) != outlen)
        {
            HANDLE_ERR(fwrite);
        }
    }
    outlen = EVP_MAX_BLOCK_LENGTH;[3]
    if(EVP_CipherFinal_ex(&ctx, outbuf, &outlen) <= 0)
    {
        HANDLE_ERR(EVP_CipherFinal_ex);
    }
    if (fwrite(outbuf, 1, outlen, out) != outlen)
    {
        HANDLE_ERR(fwrite);
    }
clear:
    EVP_CIPHER_CTX_cleanup(&ctx);
    if (in)
    {
        fclose(in);
    }
    if (out)
    {
        fclose(out);
    }
    return result;
}

int verify()
{
    const unsigned int BufferSize = 1024;
    int result = 0;
    /* Allow enough space in output buffer for additional block */
    unsigned char inbuf[BufferSize], outbuf[BufferSize];
    int inlen, outlen;
    FILE* in = NULL;
    FILE* out = NULL;


    in = fopen(__FILE__, "r+b");
    if (in == NULL)
    {
        HANDLE_ERR(fopen);
    }
    out = fopen(StrPlainFileName, "r+b");
    if (out == NULL)
    {
        HANDLE_ERR(fopen);
    }

    for(;;)
    {
        inlen = fread(inbuf, 1, BufferSize, in);

        outlen =fread(outbuf, 1, BufferSize, out);
        if (inlen != outlen)
        {
            HANDLE_ERR(EVP_CipherFinal_ex);
        }
        if (inlen == 0)
        {
            break;
        }
        if (memcmp(inbuf, outbuf, inlen) != 0)
        {
            HANDLE_ERR(memcmp);
        }
    }

clear:
    if (in)
    {
        fclose(in);
    }
    if (out)
    {
        fclose(out);
    }
    return result;
}

int saveKey(EVP_PKEY *pkey)
{
    int result = 0;
    FILE* fp = NULL;
    fp = fopen(StrPublicKeyFileName, "w+b");
    if (fp == NULL)
    {
        HANDLE_ERR(fopen);
    }
    if (PEM_write_PUBKEY(fp, pkey) <= 0)
    {
        HANDLE_ERR(PEM_write_PUBKEY);
    }
    fclose(fp);
    fp = NULL;
    fp = fopen(StrPrivateKeyFileName, "w+b");
    if (fp == NULL)
    {
        HANDLE_ERR(fopen);
    }
    if (PEM_write_PrivateKey(fp, pkey, NULL, NULL, 0, NULL, NULL) <= 0)
    {
        HANDLE_ERR(PEM_write_PrivateKey);
    }
    fclose(fp);
    fp = NULL;
clear:
    if (fp != NULL)
    {
        fclose(fp);
    }
    return result;
}

int loadKey(EVP_PKEY **ppkey)
{
    int result = 0;
    FILE* fp = NULL;
    fp = fopen(StrPublicKeyFileName, "r+b");
    if (fp == NULL)
    {
        HANDLE_ERR(fopen);
    }
    if (PEM_read_PUBKEY(fp, ppkey, NULL, NULL) == NULL)
    {
        HANDLE_ERR(PEM_read_PUBKEY);
    }
    fclose(fp);
    fp = NULL;
    fp = fopen(StrPrivateKeyFileName, "r+b");
    if (fp == NULL)
    {
        HANDLE_ERR(fopen);
    }
    if (PEM_read_PrivateKey(fp, ppkey, NULL, NULL) == NULL)
    {
        HANDLE_ERR(PEM_read_PrivateKey);
    }
    fclose(fp);
    fp = NULL;
clear:
    if (fp != NULL)
    {
        fclose(fp);
    }
    return result;
}

int main()
{
    EVP_PKEY *pkey = NULL;
    if (createKey(2048, &pkey) == 0)
    {
        printf("createKey succeeds!\n");
        if (encrypt(pkey) == 0)
        {
            printf("1. encrypt succeeds\n");
            if (decrypt(pkey) == 0)
            {
                printf("1. decrypt succeeds\n");
                if (verify() == 0)
                {
                    printf("1. verify succeeds\n");
                }
            }

        }
        if (saveKey(pkey) == 0)
        {
            EVP_PKEY_free(pkey);
            pkey = NULL;
            printf("saveKey succeeds\n");
            if (loadKey(&pkey) == 0)
            {
                printf("loadKey succeeds\n");
                if (encrypt(pkey) == 0)
                {
                    printf("2. encrypt succeeds\n");
                    if (decrypt(pkey) == 0)
                    {
                       printf("2. decrypt succeeds\n");
                       if (verify() == 0)
                       {
                           printf("2. verify succeeds\n");
                       }
                    }
                }
            }
        }
        OPENSSL_free(pkey);
    }
    return 0;
}

• _{[1]: 我曾想定义一个常量const EVP_CIPHER *MyContCipher = EVP_aes_256_cbc(void);可是编译器不接受，因为一个全局常量实际上是在main之前就确定了，这个在编译器看来就是在compiletime就能确定的值，而不管这个函数EVP_aes_256_cbc(void)的类型是否是const。事实上函数是不能在编译欺确定值的，这个就是为什么我只能定一个宏，而实际上这个函数实际上是定义了一个static的全局变量，你可以看看openssl的代码就知道了。}
• _{[2]: 这个bits决定了随后你选择怎样的cipher。我原本以为我的key的bits决定了我的cipher的method的选择，实际上cipher method，比如EVP_aes_256_cbc才决定了encryption时候设置key length的，也就是说你EVP_CIPHER_CTX_set_key_length(&ctx, EVP_CIPHER_key_length(CIPHER)总是用这个小函数传递正确的keylength，而和key设定的bits多少无关，这个我也是比较头脑不清楚的是rsa256和多少bits是否有关？应该是无关的，这个是算法层面吧？我的理解是rsa256的key的长度就是256/8=32。}
• _{[3]: 这个其实不是什么大不了的，因为我从一开始就是这么想的，所谓的final的操作都是不需要任何输入的，因为所有的数据都已经在那里了，所以函数根本就是无视你传入什么因为已经是final了。我应该是在之前的小错误误导下胡乱实验才加上这个，应该是这个函数的说明也误导了我，或者我理解有误。}

The content of the RSA private key is as follows:

-----BEGIN RSA PRIVATE KEY-----
RSAPrivateKey ::= SEQUENCE {
  version           Version,
  modulus           INTEGER,  -- n
  publicExponent    INTEGER,  -- e
  privateExponent   INTEGER,  -- d
  prime1            INTEGER,  -- p
  prime2            INTEGER,  -- q
  exponent1         INTEGER,  -- d mod (p-1)
  exponent2         INTEGER,  -- d mod (q-1)
  coefficient       INTEGER,  -- (inverse of q) mod p
  otherPrimeInfos   OtherPrimeInfos OPTIONAL
}
-----END RSA PRIVATE KEY-----

while a RSA public key contains only the following data:

-----BEGIN RSA PUBLIC KEY-----
RSAPublicKey ::= SEQUENCE {
    modulus           INTEGER,  -- n
    publicExponent    INTEGER   -- e
}
-----END RSA PUBLIC KEY-----

and this explains why the private key block is larger.

Note that a more standard format for non-RSA public keys is

-----BEGIN PUBLIC KEY-----
PublicKeyInfo ::= SEQUENCE {
  algorithm       AlgorithmIdentifier,
  PublicKey       BIT STRING
}
AlgorithmIdentifier ::= SEQUENCE {
  algorithm       OBJECT IDENTIFIER,
  parameters      ANY DEFINED BY algorithm OPTIONAL
}
-----END PUBLIC KEY-----

#include <openssl/err.h>
#include <openssl/ssl.h>
#define HANDLE_ERR(func)\
    printf("%s: %s\n", #func, ERR_reason_error_string(ERR_get_error())); goto clear;

int main()
{
    SSL_CTX *ctx=NULL;
    const SSL_METHOD *meth=SSLv3_client_method();<[2]
    BIO *STDout=NULL;
    SSL *ssl=NULL;
    SSL_load_error_strings();
    OpenSSL_add_ssl_algorithms();
    ctx=SSL_CTX_new(meth);
    if (ctx == NULL)
    {
        HANDLE_ERR(SSL_CTX_new);
    }
    ssl=SSL_new(ctx);
    if (ssl == NULL)
    {
        HANDLE_ERR(SSL_new);
    }
    STDout=BIO_new_fp(stdout,BIO_NOCLOSE);
    if (STDout == NULL)
    {
        HANDLE_ERR(BIO_new_fp);
    }

    for (int i=0; ; i++)
    {
        SSL_CIPHER *c = NULL;
        STACK_OF(SSL_CIPHER) *sk = NULL;

        sk = SSL_get_ciphers(ssl);
        if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= i))
        {
            BIO_printf(STDout,"number %d invalid\n", i);
            break;
        }
        c=sk_SSL_CIPHER_value(sk,i);
        if (c != NULL)
        {
            BIO_printf(STDout,"number[%d]:%s [%lu] [%s] [%d]\n", i, SSL_CIPHER_get_name(c),
                       SSL_CIPHER_get_id(c),
                       SSL_CIPHER_get_version(c),
                       SSL_CIPHER_get_bits(c, NULL));            
            const EVP_CIPHER* evp_cipher = EVP_get_cipherbynid(SSL_CIPHER_get_id(c));[1]
            if (evp_cipher)
            {
                BIO_printf(STDout, "name:[%s];nid:[%d];key:[%d];iv:[%d];block:[%d];flags:[%lu];",
                       EVP_CIPHER_name(evp_cipher),
                       EVP_CIPHER_nid(evp_cipher),
                       EVP_CIPHER_key_length(evp_cipher),
                       EVP_CIPHER_iv_length(evp_cipher),
                       EVP_CIPHER_block_size(evp_cipher),
                       EVP_CIPHER_flags(evp_cipher));
            }
        }
        else
        {
            break;
        }
    }
    BIO_printf(STDout,"\n");
clear:
    if (ctx)
    {
        SSL_CTX_free(ctx);
    }
    if (STDout)
    {
        BIO_free(STDout);
    }
    if (ssl)
    {
        SSL_free(ssl);
    }
    return 0;
}

• _{[1]: 目前我还找不到一个从ssl_cipher转化为evp_cipher的办法，其中使用“getbyname”也不工作的原因，evp_cipher的名字似乎很不规范，两者不匹配，而ssl_cipher的id似乎和evp的nid也无关。这个还需要研究。}
• _{[2]: 你是否想过SSLv3_client_method返回的method指针是否应该释放呢？看代码知道这个纯粹是一个方法指针表，或者叫做接口，因此只需要产生同一个实例就可以的不需要动态分配的内存。}

number[0]:ECDHE-RSA-AES256-GCM-SHA384 [50380848] [TLSv1/SSLv3] [256]
number[1]:ECDHE-ECDSA-AES256-GCM-SHA384 [50380844] [TLSv1/SSLv3] [256]
number[2]:ECDHE-RSA-AES256-SHA384 [50380840] [TLSv1/SSLv3] [256]
number[3]:ECDHE-ECDSA-AES256-SHA384 [50380836] [TLSv1/SSLv3] [256]
number[4]:ECDHE-RSA-AES256-SHA [50380820] [TLSv1/SSLv3] [256]
number[5]:ECDHE-ECDSA-AES256-SHA [50380810] [TLSv1/SSLv3] [256]
number[6]:SRP-DSS-AES-256-CBC-SHA [50380834] [TLSv1/SSLv3] [256]
number[7]:SRP-RSA-AES-256-CBC-SHA [50380833] [TLSv1/SSLv3] [256]
number[8]:DHE-DSS-AES256-GCM-SHA384 [50331811] [TLSv1/SSLv3] [256]
number[9]:DHE-RSA-AES256-GCM-SHA384 [50331807] [TLSv1/SSLv3] [256]
number[10]:DHE-RSA-AES256-SHA256 [50331755] [TLSv1/SSLv3] [256]
number[11]:DHE-DSS-AES256-SHA256 [50331754] [TLSv1/SSLv3] [256]
number[12]:DHE-RSA-AES256-SHA [50331705] [TLSv1/SSLv3] [256]
number[13]:DHE-DSS-AES256-SHA [50331704] [TLSv1/SSLv3] [256]
number[14]:DHE-RSA-CAMELLIA256-SHA [50331784] [TLSv1/SSLv3] [256]
number[15]:DHE-DSS-CAMELLIA256-SHA [50331783] [TLSv1/SSLv3] [256]
number[16]:ECDH-RSA-AES256-GCM-SHA384 [50380850] [TLSv1/SSLv3] [256]
number[17]:ECDH-ECDSA-AES256-GCM-SHA384 [50380846] [TLSv1/SSLv3] [256]
number[18]:ECDH-RSA-AES256-SHA384 [50380842] [TLSv1/SSLv3] [256]
number[19]:ECDH-ECDSA-AES256-SHA384 [50380838] [TLSv1/SSLv3] [256]
number[20]:ECDH-RSA-AES256-SHA [50380815] [TLSv1/SSLv3] [256]
number[21]:ECDH-ECDSA-AES256-SHA [50380805] [TLSv1/SSLv3] [256]
number[22]:AES256-GCM-SHA384 [50331805] [TLSv1/SSLv3] [256]
number[23]:AES256-SHA256 [50331709] [TLSv1/SSLv3] [256]
number[24]:AES256-SHA [50331701] [TLSv1/SSLv3] [256]
number[25]:CAMELLIA256-SHA [50331780] [TLSv1/SSLv3] [256]
number[26]:PSK-AES256-CBC-SHA [50331789] [TLSv1/SSLv3] [256]
number[27]:ECDHE-RSA-DES-CBC3-SHA [50380818] [TLSv1/SSLv3] [168]
number[28]:ECDHE-ECDSA-DES-CBC3-SHA [50380808] [TLSv1/SSLv3] [168]
number[29]:SRP-DSS-3DES-EDE-CBC-SHA [50380828] [TLSv1/SSLv3] [168]
number[30]:SRP-RSA-3DES-EDE-CBC-SHA [50380827] [TLSv1/SSLv3] [168]
number[31]:EDH-RSA-DES-CBC3-SHA [50331670] [TLSv1/SSLv3] [168]
number[32]:EDH-DSS-DES-CBC3-SHA [50331667] [TLSv1/SSLv3] [168]
number[33]:ECDH-RSA-DES-CBC3-SHA [50380813] [TLSv1/SSLv3] [168]
number[34]:ECDH-ECDSA-DES-CBC3-SHA [50380803] [TLSv1/SSLv3] [168]
number[35]:DES-CBC3-SHA [50331658] [TLSv1/SSLv3] [168]
number[36]:PSK-3DES-EDE-CBC-SHA [50331787] [TLSv1/SSLv3] [168]
number[37]:ECDHE-RSA-AES128-GCM-SHA256 [50380847] [TLSv1/SSLv3] [128]
number[38]:ECDHE-ECDSA-AES128-GCM-SHA256 [50380843] [TLSv1/SSLv3] [128]
number[39]:ECDHE-RSA-AES128-SHA256 [50380839] [TLSv1/SSLv3] [128]
number[40]:ECDHE-ECDSA-AES128-SHA256 [50380835] [TLSv1/SSLv3] [128]
number[41]:ECDHE-RSA-AES128-SHA [50380819] [TLSv1/SSLv3] [128]
number[42]:ECDHE-ECDSA-AES128-SHA [50380809] [TLSv1/SSLv3] [128]
number[43]:SRP-DSS-AES-128-CBC-SHA [50380831] [TLSv1/SSLv3] [128]
number[44]:SRP-RSA-AES-128-CBC-SHA [50380830] [TLSv1/SSLv3] [128]
number[45]:DHE-DSS-AES128-GCM-SHA256 [50331810] [TLSv1/SSLv3] [128]
number[46]:DHE-RSA-AES128-GCM-SHA256 [50331806] [TLSv1/SSLv3] [128]
number[47]:DHE-RSA-AES128-SHA256 [50331751] [TLSv1/SSLv3] [128]
number[48]:DHE-DSS-AES128-SHA256 [50331712] [TLSv1/SSLv3] [128]
number[49]:DHE-RSA-AES128-SHA [50331699] [TLSv1/SSLv3] [128]
number[50]:DHE-DSS-AES128-SHA [50331698] [TLSv1/SSLv3] [128]
number[51]:DHE-RSA-SEED-SHA [50331802] [TLSv1/SSLv3] [128]
number[52]:DHE-DSS-SEED-SHA [50331801] [TLSv1/SSLv3] [128]
number[53]:DHE-RSA-CAMELLIA128-SHA [50331717] [TLSv1/SSLv3] [128]
number[54]:DHE-DSS-CAMELLIA128-SHA [50331716] [TLSv1/SSLv3] [128]
number[55]:ECDH-RSA-AES128-GCM-SHA256 [50380849] [TLSv1/SSLv3] [128]
number[56]:ECDH-ECDSA-AES128-GCM-SHA256 [50380845] [TLSv1/SSLv3] [128]
number[57]:ECDH-RSA-AES128-SHA256 [50380841] [TLSv1/SSLv3] [128]
number[58]:ECDH-ECDSA-AES128-SHA256 [50380837] [TLSv1/SSLv3] [128]
number[59]:ECDH-RSA-AES128-SHA [50380814] [TLSv1/SSLv3] [128]
number[60]:ECDH-ECDSA-AES128-SHA [50380804] [TLSv1/SSLv3] [128]
number[61]:AES128-GCM-SHA256 [50331804] [TLSv1/SSLv3] [128]
number[62]:AES128-SHA256 [50331708] [TLSv1/SSLv3] [128]
number[63]:AES128-SHA [50331695] [TLSv1/SSLv3] [128]
number[64]:SEED-SHA [50331798] [TLSv1/SSLv3] [128]
number[65]:CAMELLIA128-SHA [50331713] [TLSv1/SSLv3] [128]
number[66]:PSK-AES128-CBC-SHA [50331788] [TLSv1/SSLv3] [128]
number[67]:ECDHE-RSA-RC4-SHA [50380817] [TLSv1/SSLv3] [128]
number[68]:ECDHE-ECDSA-RC4-SHA [50380807] [TLSv1/SSLv3] [128]
number[69]:ECDH-RSA-RC4-SHA [50380812] [TLSv1/SSLv3] [128]
number[70]:ECDH-ECDSA-RC4-SHA [50380802] [TLSv1/SSLv3] [128]
number[71]:RC4-SHA [50331653] [TLSv1/SSLv3] [128]
number[72]:RC4-MD5 [50331652] [TLSv1/SSLv3] [128]
number[73]:PSK-RC4-SHA [50331786] [TLSv1/SSLv3] [128]
number[74]:EDH-RSA-DES-CBC-SHA [50331669] [TLSv1/SSLv3] [56]
number[75]:EDH-DSS-DES-CBC-SHA [50331666] [TLSv1/SSLv3] [56]
number[76]:DES-CBC-SHA [50331657] [TLSv1/SSLv3] [56]
number[77]:EXP-EDH-RSA-DES-CBC-SHA [50331668] [TLSv1/SSLv3] [40]
number[78]:EXP-EDH-DSS-DES-CBC-SHA [50331665] [TLSv1/SSLv3] [40]
number[79]:EXP-DES-CBC-SHA [50331656] [TLSv1/SSLv3] [40]
number[80]:EXP-RC2-CBC-MD5 [50331654] [TLSv1/SSLv3] [40]
number[81]:EXP-RC4-MD5 [50331651] [TLSv1/SSLv3] [40]
number 82 invalid

static void show_ciphers(const OBJ_NAME *name,void *bio_)
{
    BIO *bio=bio_;
    if (islower(name->name[0]) || name->alias)[2]
    {
        //printf("alias: %s\n", name->name);
    }
    else
    {
        BIO_printf(bio,"%s\n",name->name);
    }
}

void collectCipherName()
{
    OpenSSL_add_all_algorithms();
    BIO* bio = BIO_new(BIO_s_mem());
    OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_CIPHER_METH,
                           show_ciphers,
                           bio);
    char *bptr = NULL;
    int size = BIO_get_mem_data(bio, &bptr);
    BIO_set_close(bio, BIO_NOCLOSE);[1]
    printf("[%d]\n", size);
    printf("%s\n", bptr);
    BIO_free(bio);
}

• _{[1]:实际上我压根儿不明白是否需要这个，从manpage来看这个对于source/sink来说似乎是必须的BIO_CLOSE，但是我是memory，而且BIO_NOCLOSE似乎完全没有意义。}
• _{[2]：实际上，我也不明白为什么有这些个alias，小写很容易理解.}

AES128
AES192
AES256
BF
CAMELLIA128
CAMELLIA192
CAMELLIA256
CAST
CAST-cbc
DES
DES3
DESX
RC2
SEED
aes128
aes192
aes256
bf
blowfish
camellia128
camellia192
camellia256
cast
cast-cbc
des
des3
desx
rc2
seed

AES-128-CBC
AES-128-CBC-HMAC-SHA1
AES-128-CFB
AES-128-CFB1
AES-128-CFB8
AES-128-CTR
AES-128-ECB
AES-128-OFB
AES-128-XTS
AES-192-CBC
AES-192-CFB
AES-192-CFB1
AES-192-CFB8
AES-192-CTR
AES-192-ECB
AES-192-OFB
AES-256-CBC
AES-256-CBC-HMAC-SHA1
AES-256-CFB
AES-256-CFB1
AES-256-CFB8
AES-256-CTR
AES-256-ECB
AES-256-OFB
AES-256-XTS
BF-CBC
BF-CFB
BF-ECB
BF-OFB
CAMELLIA-128-CBC
CAMELLIA-128-CFB
CAMELLIA-128-CFB1
CAMELLIA-128-CFB8
CAMELLIA-128-ECB
CAMELLIA-128-OFB
CAMELLIA-192-CBC
CAMELLIA-192-CFB
CAMELLIA-192-CFB1
CAMELLIA-192-CFB8
CAMELLIA-192-ECB
CAMELLIA-192-OFB
CAMELLIA-256-CBC
CAMELLIA-256-CFB
CAMELLIA-256-CFB1
CAMELLIA-256-CFB8
CAMELLIA-256-ECB
CAMELLIA-256-OFB
CAST5-CBC
CAST5-CFB
CAST5-ECB
CAST5-OFB
DES-CBC
DES-CFB
DES-CFB1
DES-CFB8
DES-ECB
DES-EDE
DES-EDE-CBC
DES-EDE-CFB
DES-EDE-OFB
DES-EDE3
DES-EDE3-CBC
DES-EDE3-CFB
DES-EDE3-CFB1
DES-EDE3-CFB8
DES-EDE3-OFB
DES-OFB
DESX-CBC
RC2-40-CBC
RC2-64-CBC
RC2-CBC
RC2-CFB
RC2-ECB
RC2-OFB
RC4
RC4-40
RC4-HMAC-MD5
SEED-CBC
SEED-CFB
SEED-ECB
SEED-OFB

#include <openssl/err.h>
#include <openssl/ssl.h>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cctype>
#include <iostream>
#include <vector>
#include <string>

using namespace std;

#define HANDLE_ERR(func)\
    printf("%s[%d]: %s\n", #func, __LINE__, ERR_reason_error_string(ERR_get_error())); result = -1; goto clear;

static void collect_ciphers(const OBJ_NAME *name,void *vect)
{
    vector<string>* pvect = (vector<string>*) vect;
    if (islower(name->name[0]) || name->alias)
    {
        //printf("%s\n", name->name);
    }
    else
    {
        pvect->push_back(name->name);
    }
}

void collectCipherName(vector<string>& vect)
{

    OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_CIPHER_METH,
                           collect_ciphers,
                           &vect);

}

int encrypt(const string& strName, const EVP_CIPHER* cipher, string& strKey, string& strIV)
{
    const unsigned int BufferSize = 1024;
    int toEncrypt = 1;
    int result = 0;
    /* Allow enough space in output buffer for additional block */
    unsigned char inbuf[BufferSize], outbuf[BufferSize + EVP_MAX_BLOCK_LENGTH];
    int inlen, outlen;
    FILE* in = NULL;
    FILE* out = NULL;
    /* Don't set key or IV because we will modify the parameters */
    EVP_CIPHER_CTX ctx;
    int keyLength = 0;
    int ivLength = 0;
    const string strFileName = "/tmp/" + strName;

    in = fopen(__FILE__, "r");
    if (in == NULL)
    {
        HANDLE_ERR(fopen);
    }
    out = fopen(strFileName.c_str(), "w");
    if (out == NULL)
    {
        HANDLE_ERR(fopen);
    }
    EVP_CIPHER_CTX_init(&ctx);
    if (EVP_CipherInit_ex(&ctx, cipher, NULL, NULL, NULL, toEncrypt) <= 0)
    {
        HANDLE_ERR(EVP_CipherInit_ex);
    }

    if (EVP_CIPHER_CTX_set_key_length(&ctx, EVP_CIPHER_key_length(cipher)) <= 0)
    {
        HANDLE_ERR(EVP_CIPHER_CTX_set_key_length);
    }
    // let's randomize key and iv
    keyLength = EVP_CIPHER_key_length(cipher);
    strKey.resize(keyLength);
    for (int i = 0; i < keyLength; i ++)
    {
        strKey[i] = random()%2==1?random()%26 + 'A':random()%26 + 'a';
    }

    ivLength = EVP_CIPHER_CTX_iv_length(&ctx);
    strIV.resize(ivLength);
    for (int i = 0; i < ivLength; i ++)
    {
        strIV[i] = random()%2==1?random()%26 + 'A':random()%26 + 'a';
    }

    /* We finished modifying parameters so now we can set key and IV */
    if (EVP_CipherInit_ex(&ctx, NULL, NULL, (const unsigned char*)strKey.c_str(), (const unsigned char*)strIV.c_str(), toEncrypt) <= 0)
    {
        HANDLE_ERR(EVP_CipherInit_ex);
    }

    while (!ferror(in))
    {
        inlen = fread(inbuf, 1, BufferSize, in);
        if(inlen <= 0)
        {
            if (feof(in))
            {
                break;
            }
        }
        else
        {
            if(EVP_CipherUpdate(&ctx, outbuf, &outlen, inbuf, inlen) <= 0)
            {
                HANDLE_ERR(EVP_CipherUpdate);
            }
            if (fwrite(outbuf, 1, outlen, out) != outlen)
            {
                HANDLE_ERR(fwrite);
            }
        }
    }
    if (ferror(in))
    {
        HANDLE_ERR(ferror);
    }
    if(EVP_CipherFinal_ex(&ctx, outbuf, &outlen) <= 0)
    {
        HANDLE_ERR(EVP_CipherFinal_ex);
    }
    if (fwrite(outbuf, 1, outlen, out) != outlen)
    {
        HANDLE_ERR(fwrite);
    }
clear:
    EVP_CIPHER_CTX_cleanup(&ctx);
    if (in)
    {
        fclose(in);
    }
    if (out)
    {
        fclose(out);
    }
    fflush(NULL);
    return result;
}

int verify(const string& src, const string& tgt)
{
    string cmd = "diff -q " + src + " " + tgt;
    int ret = system(cmd.c_str());
    return WEXITSTATUS(ret);
}

int decrypt(const string& strCipherName, const EVP_CIPHER* cipher, const string& strKey, const string& strIV)
{
    const unsigned int BufferSize = 1024;
    int toEncrypt = 0;
    int result = 0;
    /* Allow enough space in output buffer for additional block */
    unsigned char inbuf[BufferSize], outbuf[BufferSize + EVP_MAX_BLOCK_LENGTH];
    int inlen, outlen;
    int tmpOut = 0, tmpTotal = 0;
    FILE* in = NULL;
    FILE* out = NULL;
    /* Don't set key or IV because we will modify the parameters */
    EVP_CIPHER_CTX ctx;
    const string strPlainName = "/tmp/" + strCipherName + ".txt";
    const string strCipherFileName = "/tmp/"+strCipherName;
    in = fopen(strCipherFileName.c_str(), "r");
    if (in == NULL)
    {
        HANDLE_ERR(fopen);
    }

    out = fopen(strPlainName.c_str(), "w");
    if (out == NULL)
    {
        HANDLE_ERR(fopen);
    }
    EVP_CIPHER_CTX_init(&ctx);
    if (EVP_CipherInit_ex(&ctx, cipher, NULL, NULL, NULL, toEncrypt) <= 0)
    {
        HANDLE_ERR(EVP_CipherInit_ex);
    }

    if (EVP_CIPHER_CTX_set_key_length(&ctx, EVP_CIPHER_key_length(cipher)) <= 0)
    {
        HANDLE_ERR(EVP_CIPHER_CTX_set_key_length);
    }
    /* We finished modifying parameters so now we can set key and IV */
    if (EVP_CipherInit_ex(&ctx, NULL, NULL, (const unsigned char*)strKey.c_str(),
                          (const unsigned char*)strIV.c_str(),
                          toEncrypt) <= 0)
    {
        HANDLE_ERR(EVP_CipherInit_ex);
    }

    while (!ferror(in) && !ferror(out))
    {
        inlen = fread(inbuf, 1, BufferSize, in);
        if(inlen <= 0)
        {
            if (feof(in))
            {
                break;
            }
        }
        else
        {
            if(EVP_CipherUpdate(&ctx, outbuf, &outlen, inbuf, inlen) <= 0)
            {
                HANDLE_ERR(EVP_CipherUpdate);
            }
            tmpTotal = 0;
            while (tmpTotal < outlen)
            {
                tmpOut = fwrite(outbuf, 1, outlen, out);
                if (tmpOut <= 0)
                {
                    HANDLE_ERR(fwrite);
                }
                else
                {
                    tmpTotal+= tmpOut;
                    outlen -= tmpOut;
                }
            }
        }
    }
    if (ferror(in) && ferror(out))
    {
        HANDLE_ERR(ferror);
    }

    if(EVP_CipherFinal_ex(&ctx, outbuf, &outlen) <= 0)
    {
        HANDLE_ERR(EVP_CipherFinal_ex);
    }
    if (fwrite(outbuf, 1, outlen, out) != outlen)
    {
        HANDLE_ERR(fwrite);
    }
    fflush(in);
    fflush(out);
    if (verify(__FILE__, strPlainName) != 0)
    {
        HANDLE_ERR(verify);
    }
clear:
    EVP_CIPHER_CTX_cleanup(&ctx);
    if (in)
    {
        fclose(in);
    }
    if (out)
    {
        fclose(out);
    }
    return result;
}

int main()
{
    OpenSSL_add_all_algorithms();
    vector<string> vect;
    collectCipherName(vect);
    for (size_t i = 0; i < vect.size(); i ++)
    {
        if (vect[i].compare("AES-128-CBC-HMAC-SHA1") == 0
                || vect[i].compare("AES-256-CBC-HMAC-SHA1") == 0
                || vect[i].compare("DES-EDE3-CFB1") == 0)
        {
            continue;
        }
        const EVP_CIPHER* cipher = EVP_get_cipherbyname(vect[i].c_str());
        if (cipher)
        {
            string strKey, strIV;
            if (encrypt(vect[i], cipher, strKey, strIV) == 0)
            {
                cout << "encrypt method " << vect[i] << " succeeded " << endl;
                if (decrypt(vect[i], cipher, strKey, strIV) == 0)
                {
                    cout << "decrypt method " << vect[i] << " succeeded " << endl;
                }
                else
                {
                    cout << "decrypt method " << vect[i] << " failed " << endl;
                    break;
                }
            }
            else
            {
                cout << "encrypt method " << vect[i] << " failed " << endl;
                break;
            }
        }
    }
    return 0;
}

int encrypt(const string& strName, const EVP_CIPHER* cipher, string& strKey, string& strIV)
{
    const unsigned int BufferSize = 1024;
    int result = 0;
    /* Allow enough space in output buffer for additional block */
    unsigned char inbuf[BufferSize], outbuf[BufferSize + EVP_MAX_BLOCK_LENGTH];
    int inlen, outlen;
    FILE* in = NULL;
    FILE* out = NULL;
    EVP_CIPHER_CTX ctx;
    int keyLength = 0;
    int ivLength = 0;
    const string strFileName = "/tmp/" + strName;

    in = fopen(__FILE__, "r");
    if (in == NULL)
    {
        HANDLE_ERR(fopen);
    }
    out = fopen(strFileName.c_str(), "w");
    if (out == NULL)
    {
        HANDLE_ERR(fopen);
    }
    EVP_CIPHER_CTX_init(&ctx);

    // let's randomize key and iv
    keyLength = EVP_CIPHER_key_length(cipher);
    strKey.resize(keyLength);
    for (int i = 0; i < keyLength; i ++)
    {
        strKey[i] = random()%2==1?random()%26 + 'A':random()%26 + 'a';
    }

    ivLength = EVP_CIPHER_iv_length(cipher);
    strIV.resize(ivLength);
    for (int i = 0; i < ivLength; i ++)
    {
        strIV[i] = random()%2==1?random()%26 + 'A':random()%26 + 'a';
    }

    if (EVP_EncryptInit(&ctx, cipher, (const unsigned char*)strKey.c_str(), (const unsigned char*)strIV.c_str()) <= 0)
    {
        HANDLE_ERR(EVP_CipherInit_ex);
    }

    while (!ferror(in))
    {
        inlen = fread(inbuf, 1, BufferSize, in);
        if(inlen <= 0)
        {
            if (feof(in))
            {
                break;
            }
        }
        else
        {
            if(EVP_EncryptUpdate(&ctx, outbuf, &outlen, inbuf, inlen) <= 0)
            {
                HANDLE_ERR(EVP_CipherUpdate);
            }
            if (fwrite(outbuf, 1, outlen, out) != outlen)
            {
                HANDLE_ERR(fwrite);
            }
        }
    }
    if (ferror(in))
    {
        HANDLE_ERR(ferror);
    }

    if(EVP_EncryptFinal(&ctx, outbuf, &outlen) <= 0)
    {
        HANDLE_ERR(EVP_CipherFinal_ex);
    }
    if (fwrite(outbuf, 1, outlen, out) != outlen)
    {
        HANDLE_ERR(fwrite);
    }
clear:
    EVP_CIPHER_CTX_cleanup(&ctx);
    if (in)
    {
        fclose(in);
    }
    if (out)
    {
        fclose(out);
    }
    fflush(NULL);
    return result;
}

int verify(const string& src, const string& tgt)
{
    string cmd = "diff -q " + src + " " + tgt;
    int ret = system(cmd.c_str());
    return WEXITSTATUS(ret);[2]
}

int decrypt(const string& strCipherName, const EVP_CIPHER* cipher, const string& strKey, const string& strIV)
{
    const unsigned int BufferSize = 1024;
    int result = 0;
    /* Allow enough space in output buffer for additional block */
    unsigned char inbuf[BufferSize], outbuf[BufferSize + EVP_MAX_BLOCK_LENGTH];
    int inlen, outlen;
    int tmpOut = 0, tmpTotal = 0;
    FILE* in = NULL;
    FILE* out = NULL;
    EVP_CIPHER_CTX ctx;
    const string strPlainName = "/tmp/" + strCipherName + ".txt";
    const string strCipherFileName = "/tmp/"+strCipherName;
    in = fopen(strCipherFileName.c_str(), "r");
    if (in == NULL)
    {
        HANDLE_ERR(fopen);
    }

    out = fopen(strPlainName.c_str(), "w");
    if (out == NULL)
    {
        HANDLE_ERR(fopen);
    }
    EVP_CIPHER_CTX_init(&ctx);

    if (EVP_DecryptInit(&ctx, cipher, (const unsigned char*)strKey.c_str(),
                          (const unsigned char*)strIV.c_str()) <= 0)[1]
    {
        HANDLE_ERR(EVP_CipherInit_ex);
    }

    while (!ferror(in) && !ferror(out))
    {
        inlen = fread(inbuf, 1, BufferSize, in);
        if(inlen <= 0)
        {
            if (feof(in))
            {
                break;
            }
        }
        else
        {
            if(EVP_DecryptUpdate(&ctx, outbuf, &outlen, inbuf, inlen) <= 0)
            {
                HANDLE_ERR(EVP_CipherUpdate);
            }
            tmpTotal = 0;
            while (tmpTotal < outlen)
            {
                tmpOut = fwrite(outbuf, 1, outlen, out);
                if (tmpOut <= 0)
                {
                    HANDLE_ERR(fwrite);
                }
                else
                {
                    tmpTotal+= tmpOut;
                    outlen -= tmpOut;
                }
            }
        }
    }
    if (ferror(in) && ferror(out))
    {
        HANDLE_ERR(ferror);
    }

    if(EVP_DecryptFinal(&ctx, outbuf, &outlen) <= 0)
    {
        HANDLE_ERR(EVP_CipherFinal_ex);
    }
    if (fwrite(outbuf, 1, outlen, out) != outlen)
    {
        HANDLE_ERR(fwrite);
    }
    fflush(in);
    fflush(out);
    if (verify(__FILE__, strPlainName) != 0)
    {
        HANDLE_ERR(verify);
    }
clear:
    EVP_CIPHER_CTX_cleanup(&ctx);
    if (in)
    {
        fclose(in);
    }
    if (out)
    {
        fclose(out);
    }
    return result;
}

• _{[1]: 我之前使用比较类似的EVP_CipherInit_ex，这个其实差别不大，不过是否需要分两次分别传递参数cipher和key,iv呢？似乎是不需要，之前的代码是从openssl/enc的代码演变而来的。其实包括列表所有的cipher的方法也是从这个代码来的。}
• _{[2]: 这个是老生常谈了，system的返回值并非是命令的状态，所以需要WEXITSTATUS。}

#include <openssl/err.h>
#include <openssl/ssl.h>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cctype>
#include <iostream>
#include <vector>
#include <string>

using namespace std;

#define HANDLE_ERR(func)\
    printf("%s[%d]: %s\n", #func, __LINE__, ERR_reason_error_string(ERR_get_error())); result = -1; goto clear;

static void collect_ciphers(const OBJ_NAME *name,void *vect)
{
    vector<string>* pvect = (vector<string>*) vect;
    if (islower(name->name[0]) || name->alias)
    {
        //printf("%s\n", name->name);
    }
    else
    {
        pvect->push_back(name->name);
    }
}

void collectCipherName(vector<string>& vect)
{

    OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_CIPHER_METH,
                           collect_ciphers,
                           &vect);
}

void getKey(const EVP_CIPHER* cipher, string& strKey, string& strIV)
{
    int keyLength = 0;
    int ivLength = 0;
    // let's randomize key and iv
    keyLength = EVP_CIPHER_key_length(cipher);
    strKey.resize(keyLength);
    for (int i = 0; i < keyLength; i ++)
    {
        strKey[i] = random()%2==1?random()%26 + 'A':random()%26 + 'a';
    }

    ivLength = EVP_CIPHER_iv_length(cipher);
    strIV.resize(ivLength);
    for (int i = 0; i < ivLength; i ++)
    {
        strIV[i] = random()%2==1?random()%26 + 'A':random()%26 + 'a';
    }
}

int verify(const string& strName)
{
    const string src = __FILE__;
    const string tgt = "/tmp/" + strName + ".txt";;
    string cmd = "diff -q " + src + " " + tgt;
    int ret = system(cmd.c_str());
    return WEXITSTATUS(ret);
}

int crypt(const string& strName, const EVP_CIPHER* cipher, string& strKey, string& strIV, int encrypt)
{
    const unsigned int BufferSize = 8*1024;
    int result = 0;
    /* Allow enough space in output buffer for additional block */
    unsigned char buf[EVP_ENCODE_LENGTH(BufferSize)];
    int inlen, outlen;
    BIO* in = NULL;
    BIO* out = NULL;
    BIO* benc = NULL;
    EVP_CIPHER_CTX* ctx = NULL;

    string strInFileName;
    string strOutFileName;

    if (encrypt)
    {
        strInFileName = __FILE__;
        strOutFileName = "/tmp/" + strName;
    }
    else
    {
        strInFileName = "/tmp/" + strName;
        strOutFileName = "/tmp/" + strName + ".txt";
    }

    in = BIO_new(BIO_s_file());
    if (in == NULL)
    {
        HANDLE_ERR(BIO_new);
    }
    if (BIO_read_filename(in,(void*)strInFileName.c_str()) <= 0)
    {
        HANDLE_ERR(BIO_read_filename);
    }
    out = BIO_new(BIO_s_file());
    if (out == NULL)
    {
        HANDLE_ERR(BIO_new);
    }
    if (BIO_write_filename(out, (void*)strOutFileName.c_str()) <= 0)
    {
        HANDLE_ERR(BIO_write_filename);
    }
    if ((benc = BIO_new(BIO_f_cipher())) == NULL)
    {
        HANDLE_ERR(BIO_new);
    }
    if (BIO_get_cipher_ctx(benc, &ctx) <= 0)
    {
        HANDLE_ERR(BIO_get_cipher_ctx);
    }

    if (!EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, encrypt))
    {
        HANDLE_ERR(EVP_CipherInit_ex);
    }
    if (!EVP_CipherInit_ex(ctx, NULL, NULL, (const unsigned char*)strKey.c_str(),
                          (const unsigned char*)strIV.c_str(), encrypt))
    {
        HANDLE_ERR(EVP_CipherInit_ex);
    }

    if ((out = BIO_push(benc,out)) == NULL)
    {
        HANDLE_ERR(BIO_push);
    }
    while (true)
    {
        inlen = BIO_read(in, (char *)buf, BufferSize);
        if (inlen <= 0)
        {
            break;
        }
        if (BIO_write(out, (char *)buf, inlen) != inlen)
        {
            HANDLE_ERR(BIO_write);
        }
    }

    if (!BIO_flush(out))
    {
        HANDLE_ERR(BIO_flush);
    }
clear:
    if (in)
    {
        BIO_free(in);
    }
    if (out)
    {
        BIO_free_all(out);
    }
//    if (benc)
//    {
//        BIO_free(benc);
//    }
    return result;
}

int main()
{
    CRYPTO_malloc_init();
    ERR_load_crypto_strings();
    OpenSSL_add_all_algorithms();
    vector<string> vect;
    collectCipherName(vect);
    for (size_t i = 0; i < vect.size(); i ++)
    {
        if ((vect[i].compare("AES-128-CBC-HMAC-SHA1") == 0
                || vect[i].compare("AES-256-CBC-HMAC-SHA1") == 0
                || vect[i].compare("DES-EDE3-CFB1") == 0))
        {
            continue;
        }
        const EVP_CIPHER* cipher = EVP_get_cipherbyname(vect[i].c_str());
        if (cipher)
        {
            string strKey, strIV;
            getKey(cipher, strKey, strIV);
            if (crypt(vect[i], cipher, strKey, strIV, 1) == 0)
            {
                cout << "encrypt method " << vect[i] << " succeeded " << endl;
                if (crypt(vect[i], cipher, strKey, strIV, 0) == 0)
                {
                    cout << "decrypt method " << vect[i] << " succeeded " << endl;
                    if (verify(vect[i]) == 0)
                    {
                        cout << "verify method " << vect[i] << " succeeded " << endl;
                    }
                    else
                    {
                        cout << "verify method " << vect[i] << " failed " << endl;
                        break;
                    }
                }
                else
                {
                    cout << "decrypt method " << vect[i] << " failed " << endl;
                    break;
                }
            }
            else
            {
                cout << "encrypt method " << vect[i] << " failed " << endl;
                break;
            }
        }
    }
    return 0;
}

#include<fstream>
#include<string>
#include <cstring>
#include<ctype.h>
#include <cstdlib>
#include <iostream>

#define _TABSIZE	4

using namespace std;

int tabsize = _TABSIZE;

class token {
public:
	token() : _what(code) {}
protected:
	enum type {code, comment, pp, keyword};
	string _str;
	type _what;
	friend istream& operator>>(istream&, token&);
	friend ostream& operator<<(ostream&, const token&);
};

bool iskeyword(const string& s)
{
	static const char* keywords[] = {
		"and",
		"and_eq",
		"asm",
		"auto",
		"bitand",
		"bitor",
		"bool",
		"break",
		"case",
		"catch",
		"char",
		"class",
		"compl",
		"const",
		"const_cast",
		"continue",
		"default",
		"delete",
		"do",
		"double",
		"dynamic_cast",
		"else",
		"enum",
		"explicit",
		"export",
		"extern",
		"false",
		"float",
		"for",
		"friend",
		"goto",
		"if",
		"inline",
		"int",
		"long",
		"mutable",
		"namespace",
		"new",
		"not",
		"not_eq",
		"operator",
		"or",
		"or_eq",
		"private",
		"protected",
		"public",
		"register",
		"reinterpret_cast",
		"return",
		"short",
		"signed",
		"sizeof",
		"static",
		"static_cast",
		"struct",
		"switch",
		"template",
		"this",
		"throw",
		"true",
		"try",
		"typedef",
		"typeid",
		"typename",
		"union",
		"unsigned",
		"using",
		"virtual",
		"void",
		"volatile",
		"wchar_t",
		"while",
		"xor",
		"xor_eq"
	};

	for (size_t i = 0; i < sizeof(keywords) / sizeof(char*); i++)
		if (string(keywords[i]) == s)
			return true;

	return false;
}

bool containspp(const string& s)
{
	static const char* pptokens[] = {
		"define",
		"elif",
		"else",
		"endif",
		"error",
		"if",
		"ifdef",
		"ifndef",
		"include",
		"line",
		"pragma",
		"undef"
	};

	for (size_t i = 0; i < sizeof(pptokens) / sizeof(char*); i++)
		if (s.find(pptokens[i]) != string::npos)
			return true;

	return false;
}

istream& operator>>(istream& is, token& t)
{
	t._str = "", t._what = token::code;
	int c = is.get();
	switch (c) {
		case '/':
			c = is.get();
			if (c == '*') {
				t._str = "/*";
				t._what = token::comment;
				while (1) {
					c = is.get();
					if (c == EOF)
						return is.unget(), is.clear(), is;
					if (c == '/') {
						if (t._str.length() > 2 &&
							t._str[t._str.length() - 1] == '*') {
							return t._str += '/', is;
						}
					}
					t._str += (char)c;
				}
			} else if (c == '/') {
				t._str = "//";
				t._what = token::comment;
				c = is.get();
				while (c != '\n' && c != EOF) {
					t._str += (char)c;
					c = is.get();
				}
				if (c == '\n') {
					t._str += '\n';
				}
				return is;
			}
			t._str = '/';
			return is.unget(), is.clear(), is;
		case '#':
			t._str = '#';
			c = is.get();
			while (strchr(" \r\n\t", c)) {
				t._str += (char)c;
				c = is.get();
			}
			if (c == EOF)
				return is.unget(), is.clear(), is;
			while (strchr("abcdefghijklmnopqrstuvwxyz", c)) {
				t._str += (char)c;
				c = is.get();
			}
			is.unget(), is.clear();
			if (containspp(t._str))
				t._what = token::pp;
			return is;
		case '\'':
		case '"': {
			char q = (char)c;
			t._str = q;
			while (1) {
				c = is.get();
				if (c == EOF)
					return is.unget(), is.clear(), is;
				if (c == q) {
					if (t._str.length() >= 2) {
						if (!(t._str[t._str.length() - 1] == '\\' &&
							t._str[t._str.length() - 2] != '\\'))
							return t._str += q, is;
					} else {
						return t._str += q, is;
					}
				}
				t._str += (char)c;
			}
		}
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f':
		case 'g':
		case 'i':
		case 'l':
		case 'm':
		case 'n':
		case 'o':
		case 'p':
		case 'r':
		case 's':
		case 't':
		case 'u':
		case 'v':
		case 'w':
		case 'x':
			t._str += (char)c;
			c = is.get();
			while (isalpha(c) || isdigit(c) || c == '_') {
				t._str += (char)c;
				c = is.get();
			}
			is.unget(), is.clear();
			if (iskeyword(t._str))
				t._what = token::keyword;
			return is;
		case EOF:
			return is;
		default:
			t._str += (char)c;
			c = is.get();
			while (c != '/' && c != '#' && !strchr("abcdefgilmnoprstuvwx", c) &&
				c != '\'' && c != '"' && c != EOF) {
				t._str += (char)c;
				c = is.get();
			}
			is.unget(), is.clear();
			return is;
	}
}

string html(const string& s)
{
	string s1;
	string::size_type i;
	for (i = 0; i < s.length(); i++) {
		switch (s[i]) {
			case '&':
				s1 += "&amp;";
				break;
			case '<':
				s1 += "&lt;";
				break;
			case '>':
				s1 += "&gt;";
				break;
			case '"':
				s1 += "&quot;";
				break;
			case '\t':
				// I suspect this is correct for tab?
			    //s1.append(tabsize, ' ');
			    s1 += "&#09;";
				break;
			default:
				s1 += s[i];
		}
	}
	return s1;
}

ostream& operator<<(ostream& os, const token& t)
{
	if (t._what == token::code)
		os << html(t._str);
	else if (t._what == token::comment)
		os << "<span class=comment>" << html(t._str) << "</span>";
	else if (t._what == token::keyword)
		os << "<span class=keyword>" << html(t._str) << "</span>";
	else if (t._what == token::pp)
	    os << "<span class=pp>" << html(t._str) << "</span>";
	else
	    os << html(t._str);
	return os;
}

int main(int argc, char **argv)
{
	if (argc != 2 && argc != 3) {
		cout << "usage: cpphtml srcfile [tab size]" << endl;
		return 0;
	}
	ifstream is(argv[1]);
	if (!is.good()) {
		cerr << "bad input file" << endl;
		return -1;
	}
	if (argc == 3) {
		tabsize = atoi(argv[2]);
		if (tabsize <= 0)
			tabsize = _TABSIZE;
	}
	// let's use htm or html ext to generate new file
	string outName = argv[1];
	outName += ".htm";
	ofstream out(outName.c_str(), std::fstream::out);
	if (!out.good())
	{
	    cerr << "bad output file" << endl;
	            return -1;
	}
	//actually what I want is a embedded part of html, not whole file
//	out << "<html><head><style>";
//	out << ".keyword{color:rgb(0,0,255);}";
//	out << ".comment{color:rgb(0,128,0);}";
//	out << ".pp{color:rgb(0,0,255);}";
//	out << "</style><body>";
	out << "<pre style=\"font-family:courier;font-size:10pt\">";
	token t;
	while (is >> t) {
	    out << t;
	}
	//out << "</pre></body></html>";
	out << "</pre>";
	return 0;
}

/*
 * keyTest.cpp
 *
 *  Created on: Feb 19, 2018
 *      Author: nick
 */

#include <openssl/ssl.h>
#include <openssl/crypto.h>
#include <openssl/evp.h>
#include <openssl/asn1t.h>
#include <openssl/err.h>

#include <cstdio>
#include <iostream>
#include <cstring>

using namespace std;


int main()
{
    OPENSSL_init();
    CRYPTO_malloc_init();
    ERR_load_crypto_strings();
    OpenSSL_add_all_algorithms();
    for (int i = 0; i < EVP_PKEY_asn1_get_count(); i++)
    {
        const EVP_PKEY_ASN1_METHOD * ameth = EVP_PKEY_asn1_get0(i);
        int pkeyId=0, pkeyBaseId = 0;
        const char* pinfo = NULL, *pstr = NULL;
        if (EVP_PKEY_asn1_get0_info(&pkeyId, &pkeyBaseId, NULL,
                        &pinfo, &pstr,
                            ameth) > 0)
        {
            pinfo = pinfo?pinfo:" none ";
            pstr = pstr?pstr:" none ";
            cout << pkeyId << "|" << pkeyBaseId << "|" << pinfo << "|" << pstr << endl;
        }
    }
}

6|6|OpenSSL RSA method|RSA
19|6| none | none 
28|28|OpenSSL PKCS#3 DH method|DH
66|116| none | none 
67|116| none | none 
70|116| none | none 
113|116| none | none 
116|116|OpenSSL DSA method|DSA
408|408|OpenSSL EC algorithm|EC
855|855|OpenSSL HMAC method|HMAC
894|894|OpenSSL CMAC method|CMAC

/*
 * keyTest.cpp
 *
 *  Created on: Feb 19, 2018
 *      Author: nick
 */
#include <openssl/ssl.h>
#include <openssl/crypto.h>
#include <openssl/evp.h>
#include <openssl/asn1t.h>
#include <openssl/err.h>

#include <cstdio>
#include <iostream>
#include <cstring>

using namespace std;

#define HANDLE_ERR(func)\
    printf("%s[%d]: %s\n", #func, __LINE__, ERR_reason_error_string(ERR_get_error())); goto clear;

static int genpkey_cb(EVP_PKEY_CTX *ctx)
{
    char c='*';
    BIO *b = (BIO*)EVP_PKEY_CTX_get_app_data(ctx);
    int p;
    p = EVP_PKEY_CTX_get_keygen_info(ctx, 0);
    if (p == 0) c='.';
    if (p == 1) c='+';
    if (p == 2) c='*';
    if (p == 3) c='\n';
    BIO_write(b,&c,1);
    (void)BIO_flush(b);
    return 1;
}
int main()
{
    EVP_PKEY_CTX *ctx = NULL;
    BIO* out = NULL;
    EVP_PKEY *pkey = NULL;
    OPENSSL_init();
    CRYPTO_malloc_init();
    ERR_load_crypto_strings();
    OpenSSL_add_all_algorithms();
    for (int i = 0; i < EVP_PKEY_asn1_get_count(); i++)
    {
        const EVP_PKEY_ASN1_METHOD * ameth = EVP_PKEY_asn1_get0(i);
        int pkeyId=0;
        const char* pinfo = NULL, *pstr = NULL;
        if (EVP_PKEY_asn1_get0_info(&pkeyId, NULL, NULL,
                        &pinfo, &pstr, ameth) > 0)
        {
            pinfo = pinfo?pinfo:" none ";
            pstr = pstr?pstr:" none ";
            cout << pkeyId << "|" << pinfo << "|" << pstr << endl;
            ctx = EVP_PKEY_CTX_new_id(pkeyId, NULL);
            if (!ctx)
            {
                HANDLE_ERR(EVP_PKEY_CTX_new_id);
            }
            if (EVP_PKEY_keygen_init(ctx) <= 0)
            {
                HANDLE_ERR(EVP_PKEY_keygen_init);
            }
            out = BIO_new_fp (stdout, BIO_NOCLOSE);
            if (!out)
            {
                HANDLE_ERR(BIO_new_fp);
            }
            EVP_PKEY_CTX_set_cb(ctx, genpkey_cb);
            EVP_PKEY_CTX_set_app_data(ctx, out);
            if (EVP_PKEY_keygen(ctx, &pkey) <= 0)
            {
                HANDLE_ERR(EVP_PKEY_keygen);
            }
            if (EVP_PKEY_print_private(out, pkey, 0, NULL) <= 0)
            {
                HANDLE_ERR(EVP_PKEY_print_private);
            }
            clear:
            if (ctx)
            {
                EVP_PKEY_CTX_free(ctx);
            }
        }
    }
    return 0;
}

int main()
{
    unsigned char* seed = NULL;
    int seedlen = 100;
    int result = -1;
    int nbits = 2048;
    DSA* dsa = DSA_new();
    seed = (unsigned char*)malloc(seedlen);
    for (int i = 0; i < seedlen; i ++)
    {
        seed[i] = random()%26+'a';
    }
    if (DSA_generate_parameters_ex(dsa, nbits, seed, seedlen, NULL, NULL, NULL) <= 0)
    {
        cout << "failure" << endl;
    }
    else
    {
        cout << " succeed " << endl;
        result = 0;
    }
    if (result == 0)
    {
        DSA_print_fp(stdout, dsa, 4);
    }
clear:
    if (dsa)
    {
        DSA_free(dsa);
    }
    if (seed)
    {
        free(seed);
    }
    return result;
}

#include "openssl/ssl.h"
#include "openssl/err.h"
#include <vector>
#include <string>
#include <iostream>

using namespace std;

static void list_md_fn(const EVP_MD *m, const char *from, const char *to, void *arg)
{
    const char *mname;
    /* Skip aliases */
    if (!m)
        return;
    mname = OBJ_nid2ln(EVP_MD_type(m));
    /* Skip shortnames */
    if (strcmp(from, mname))
        return;
    /* Skip clones */
    if (EVP_MD_flags(m) & EVP_MD_FLAG_PKEY_DIGEST)
        return;
    if (strchr(mname, ' '))
        mname= EVP_MD_name(m);
    vector<string>* pvect = (vector<string>*) arg;
    pvect->push_back(mname);
}

int main(void)
{
    CRYPTO_malloc_init();
    ERR_load_crypto_strings();
    OpenSSL_add_all_algorithms();
    BIO* bio_err = NULL;
    vector<string> vect;
    EVP_MD_do_all_sorted(list_md_fn, &vect);
    for (size_t i = 0; i < vect.size(); i ++)
    {
        cout << vect[i] << endl;
    }
    return 0;
}

md4
md5
mdc2
ripemd160
sha
sha1
sha224
sha256
sha384
sha512
whirlpool

#include "openssl/ssl.h"
#include "openssl/err.h"
#include <vector>
#include <string>
#include <iostream>

using namespace std;

#define HANDLE_ERR(func)\
    printf("%s[%d]: %s\n", #func, __LINE__, ERR_reason_error_string(ERR_get_error())); goto clear;

void digest(const string& strMD)
{
#undef BUFSIZE
#define BUFSIZE 1024*8
    unsigned char buf[BUFSIZE];
    const string strFile = __FILE__;
    BIO* in = NULL;
    BIO* bmd = NULL;
    BIO* inp = NULL;
    BIO* out = NULL;
    const EVP_MD *md=NULL;
    int i = 0, len = 0;
    in=BIO_new(BIO_s_file());
    if (!in)
    {
        HANDLE_ERR(BIO_new(BIO_s_file()));
    }
    if (BIO_read_filename(in,strFile.c_str()) <= 0)
    {
        HANDLE_ERR(BIO_read_filename);
    }
    bmd=BIO_new(BIO_f_md());
    if (!bmd)
    {
        HANDLE_ERR(BIO_new(BIO_f_md()));
    }

    out = BIO_new_fp(stdout, BIO_NOCLOSE);
    if (!out)
    {
        HANDLE_ERR(BIO_new_fp);
    }
    md = EVP_get_digestbyname(strMD.c_str());
    if (!md)
    {
        HANDLE_ERR(EVP_get_digestbyname);
    }

    if (!BIO_set_md(bmd,md))
    {
        HANDLE_ERR(BIO_set_md);
    }
    inp=BIO_push(bmd,in);
    for (;;)
    {
        i=BIO_read(inp,(char *)buf,BUFSIZE);
        if(i < 0)
        {
            HANDLE_ERR(BIO_read);
        }
        if (i == 0) break;
    }

    len = BIO_gets(inp,(char *)buf,BUFSIZE);
    if (len < 0)
    {
        HANDLE_ERR(BIO_gets);
    }
    BIO_printf(out, "%s(%s)", strFile.c_str(), EVP_MD_name(md));
    for (i=0; i<(int)len; i++)
    {
        BIO_printf(out, "%02x",buf[i]);
    }
    BIO_printf(out, "\n");
clear:
    if (in)
    {
        BIO_free(in);
    }
    if (bmd)
    {
        BIO_free(bmd);
    }
    if (out)
    {
        BIO_free(out);
    }
}

dgstTest.cpp(MD4)7ed5abb9e73db7e0cdca8087ed47d591
dgstTest.cpp(MD5)d162fb7a450600883e470cd99d11a9bc
dgstTest.cpp(MDC2)c90fded0cbe6d85ee8fd7ed1ffb0caac
dgstTest.cpp(RIPEMD160)100d332f2b9b50fb918d486e99fe663a12bdf3d4
dgstTest.cpp(SHA)67c656842faebf31066f352d5dcd48efd3690e5b
dgstTest.cpp(SHA1)b0267c2d5f35a809d1d1b0e2d3330f3df31b9776
dgstTest.cpp(SHA224)914ad20697d74ef4f6a3ec5ac05e2c92b08bd6356e588035d784134c
dgstTest.cpp(SHA256)510df323593d778558f163ea763599dbe89450caa6a4afbcf6c8da9947e81bd1
dgstTest.cpp(SHA384)af6c9d7710bf42cb183f03cefd4c023f2113a1065b58ec54643d5601e3eb304ad8dc1c4c6c7282c846768864b5b91d90
dgstTest.cpp(SHA512)db57d634a4cbe3c3dddfb0aa5e1affc610b4e985a932e64bfe3787cfb682fdd1dcb482047baaa03816db0c5aeee652b978b7bd350c30bd0b4699b223f2cfe5ee
dgstTest.cpp(whirlpool)1d719684050d53c69e8102023fa49341bf61311a081cb369a260a30562b87d942c69923227a8ceb8d3e61086bdf595c316b37cd8c2ebdc8b1b281d1d3b6a2361

		case EVP_PKEY_CTRL_DSA_PARAMGEN_MD:
		if (EVP_MD_type((const EVP_MD *)p2) != NID_sha1   &&
		    EVP_MD_type((const EVP_MD *)p2) != NID_sha224 &&
		    EVP_MD_type((const EVP_MD *)p2) != NID_sha256)
			{
			DSAerr(DSA_F_PKEY_DSA_CTRL, DSA_R_INVALID_DIGEST_TYPE);
			return 0;
			}
		// This is an obvious typo because md is for digest and for param gen it should be pmd
		//dctx->md = p2;
		dctx->pmd = p2;
		return 1;

#include "openssl/ssl.h"
#include "openssl/err.h"
static void list_md_fn(const EVP_MD *m, const char *from, const char *to, void *arg)
{
    if (m)
        BIO_printf((BIO*)arg, "%s\n", EVP_MD_name(m));
    else
    {
        // if you read source code, you know this is case of alias
        if (!from)
            from = "<undefined>";
        if (!to)
            to = "<undefined>";
        BIO_printf((BIO*)arg, "%s => %s\n", from, to);
    }
}
static void list_md(BIO *out)
{
    EVP_MD_do_all_sorted(list_md_fn, out);
}
static void list_cipher_fn(const EVP_CIPHER *c, const char *from, const char *to, void *arg)
{
    if (c)
        BIO_printf((BIO*)arg, "%s\n", EVP_CIPHER_name(c));
    else
    {
        if (!from)
            from = "<undefined>";
        if (!to)
            to = "<undefined>";
        BIO_printf((BIO*)arg, "%s => %s\n", from, to);
    }
}
static void list_cipher(BIO *out)
{
    EVP_CIPHER_do_all_sorted(list_cipher_fn, out);
}
static void list_pkey(BIO *out)
{
    int i;
    for (i = 0; i < EVP_PKEY_asn1_get_count(); i++)
    {
        const EVP_PKEY_ASN1_METHOD *ameth;
        int pkey_id, pkey_base_id, pkey_flags;
        const char *pinfo, *pem_str;
        ameth = EVP_PKEY_asn1_get0(i);
        EVP_PKEY_asn1_get0_info(&pkey_id, &pkey_base_id, &pkey_flags,
                        &pinfo, &pem_str, ameth);
        if (pkey_flags & ASN1_PKEY_ALIAS)
        {
            BIO_printf(out, "Name: %s\n",
                    OBJ_nid2ln(pkey_id));
            BIO_printf(out, "\tType: Alias to %s\n",
                    OBJ_nid2ln(pkey_base_id));
        }
        else
        {
            BIO_printf(out, "Name: %s\n", pinfo);
            BIO_printf(out, "\tType: %s Algorithm\n",
                pkey_flags & ASN1_PKEY_DYNAMIC ?
                    "External" : "Builtin");
            BIO_printf(out, "\tOID: %s\n", OBJ_nid2ln(pkey_id));
            BIO_printf(out, "\tOID: %d\n", (pkey_id));
            if (pem_str == NULL)
                pem_str = "(none)";
            BIO_printf(out, "\tPEM string: %s\n", pem_str);
        }
    }
}
int main(void)
{
    BIO* out = NULL;
    OPENSSL_init();
    CRYPTO_malloc_init();
    ERR_load_crypto_strings();
    OpenSSL_add_all_algorithms();
    out = BIO_new_fp(stdout, BIO_NOCLOSE);
    if (out)
    {
        BIO_printf(out, "**************method list*****************\n");
        list_md(out);
        BIO_printf(out, "**************cipher list*****************\n");
        list_cipher(out);
        BIO_printf(out, "**************pkey list*****************\n");
        list_pkey(out);
        BIO_free(out);
    }
    return 0;
}

int main()
{
    BIO* out = NULL;
    EVP_PKEY* pkey = NULL;
    OPENSSL_init();
    CRYPTO_malloc_init();
    ERR_load_crypto_strings();
    OpenSSL_add_all_algorithms();
    out = BIO_new_fp(stdout, BIO_NOCLOSE);
    if (out)
    {
        EVP_PKEY* dsakey = EVP_PKEY_new();
        if (dsakey)
        {
            if (EVP_PKEY_assign_DSA(dsakey, DSA_new())>0)[1]
            {
                EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(dsakey, NULL);
                if (ctx)
                {
                    if (EVP_PKEY_paramgen_init(ctx))
                    {
                        const char* q_bits = "160";//224; 256;
                        const char* bits = "2048";
                        const char* method="sha1"; // "sha224", "sha256";
                        if (EVP_PKEY_CTX_ctrl_str(ctx, "dsa_paramgen_q_bits", q_bits)>0
                            && EVP_PKEY_CTX_ctrl_str(ctx, "dsa_paramgen_bits", bits)>0
                            && EVP_PKEY_CTX_ctrl_str(ctx, "dsa_paramgen_md", method)>0)[2]
                        {
                            if (EVP_PKEY_paramgen(ctx, &pkey)>=0)[3]
                            {
                                EVP_PKEY_print_public(out, pkey, 4, NULL);
                                EVP_PKEY_print_private(out, pkey, 4, NULL);
                            }
                        }
                    }
                    EVP_PKEY_CTX_free(ctx);
                }
            }
            EVP_PKEY_free(dsakey);
        }
        BIO_free(out);
    }
    return 0;
}}

• _{[1]: 你要非常小心这个EVP_PKEY_assign_DSA陷阱，实际上它不过是把一个DSA的指针放到了EVP_PKAY的结构里，随后你在释放它的时候自然就要释放传入的DSA指针，我一开始的时候声明一个专门的DSA变量指针然后assign之后依然去释放它导致了双重释放。很明显的assign的意思就是所有权的交接，所以我现在改为一个临时变量的参数传递，省略了困惑，因为查看代码知道EVP_PKEY_assign_DSA成功与否取决于传入的指针是否为NULL所以这个是一个完美的解决方法。因为我之所以需要一个DSA完全是为了类型设定ctx的需求，我并不直接操作DSA，这个差异可以在随后的一个例子里看到直接使用。}
• _{[2]: 另一种方式就是采用原生的参数传递，这个效率要高因为前者是命令行的工具方便用户。}

  
                      if (EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DSA, EVP_PKEY_OP_PARAMGEN,
                                            EVP_PKEY_CTRL_DSA_PARAMGEN_BITS, nbits, NULL)>0 &&
                          EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DSA, EVP_PKEY_OP_PARAMGEN,
                                            EVP_PKEY_CTRL_DSA_PARAMGEN_Q_BITS, qbits, NULL)>0 &&
                          EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_DSA, EVP_PKEY_OP_PARAMGEN,
                                            EVP_PKEY_CTRL_DSA_PARAMGEN_MD, 0, (char*)EVP_sha256())>0)

• _{[3]: 其实如果你不想使用evp的方法，你直接使用dsa的方法似乎代码更简单，但是你可能失去一些通用性，当然也不是不可以，你肯定可以更直接的控制效率更高一些吧。}

  
  int main(void)
  {
      DSA* dsa = DSA_new();
      if (dsa)
      {
          unsigned char seed[] = "abcdefghijklmnopqrstxyz";
          int nbits = 2048;
          if (DSA_generate_parameters_ex(dsa, nbits, seed, sizeof(seed), NULL, NULL, NULL)>0)
          {
              //if (DSA_generate_key(dsa)>0)
              {
                  DSA_print_fp(stdout, dsa, 4);
              }
          }
          DSA_free(dsa);
      }
  }

  还有一个似乎不用解释的解释，就是关于函数名字的误导，我始终理解这个DSA_generate_parameters，或者EVP_PKEY_paramgen是专门产生参数用来生成pkey,因此最后再调用key_gen的函数实际产生key，这个也许是我个人的理解障碍，也许大多数人和命名者认为这个是显而易见的无需解释。openssl的文档实在是都是针对专家和写作者的，完全不做最基本的解释，似乎我们这些使用者都是如他们一样的有最基本的概念与常识。这个也屡屡让我感到汗颜。我想说的你调用DSA_generate_parameters_ex的时候key就产生了，DSA_generate_key完全是为了另一个目的而设定的函数。

#include <cstdio>
#include <cstdlib>
#include <string>
#include "libssh2.h"
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <iostream>

using namespace std;

#define BUFSIZE 32000

const unsigned long int BufSize=2048;

class MySSH2
{
private:
	int m_sock;
	LIBSSH2_SESSION *m_session;
	LIBSSH2_CHANNEL *m_channel;
	char m_err[1025];
	string m_strIp;
	string m_strUser;
	string m_strPasswd;
	bool bInitialized;
public:
	int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
	{
	    struct timeval timeout;
	    int rc;
	    fd_set fd;
	    fd_set *writefd = NULL;
	    fd_set *readfd = NULL;
	    int dir;

	    timeout.tv_sec = 10;
	    timeout.tv_usec = 0;

	    FD_ZERO(&fd);

	    FD_SET(socket_fd, &fd);

	    /* now make sure we wait in the correct direction */
	    dir = libssh2_session_block_directions(session);

	    if(dir & LIBSSH2_SESSION_BLOCK_INBOUND)
	        readfd = &fd;

	    if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
	        writefd = &fd;

	    rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);

	    return rc;
	}

	bool init_library()
	{
		if (libssh2_init (0) == 0)
		{
			bInitialized = true;
		}
	}

	bool init_socket()
	{
		if (m_sock != -1)
		{
			return true;
		}
		unsigned long hostaddr;

		struct sockaddr_in sin;

		hostaddr = inet_addr(m_strIp.c_str());

		m_sock = socket(AF_INET, SOCK_STREAM, 0);

		sin.sin_family = AF_INET;
		sin.sin_port = htons(22);
		sin.sin_addr.s_addr = hostaddr;
		if (connect(m_sock, (struct sockaddr*)(&sin),	sizeof(struct sockaddr_in)) != 0)
		{
			snprintf(m_err,1024, "failed to connect!\n");
			uninit_socket();
			return false;
		}
		return true;
	}

	bool init_session()
	{
		if (m_session != NULL)
		{
			return true;
		}
		int rc;
		if (m_sock == -1)
		{
			snprintf(m_err, 1024, "Socket is not initialized \n");
			return false;
		}
		m_session = libssh2_session_init();
		if (!m_session)
		{
			return false;
		}

		/* tell libssh2 we want it all done non-blocking */
		libssh2_session_set_blocking(m_session, 0);
		while ((rc = libssh2_session_handshake(m_session, m_sock)) == LIBSSH2_ERROR_EAGAIN)
		{
			waitsocket(m_sock, m_session);
		}
		if (rc)
		{
			snprintf(m_err, 1024, "Failure establishing SSH session: %d\n", rc);
			uninit_session();
			return false;
		}

		while ((rc = libssh2_userauth_password(m_session, m_strUser.c_str(), m_strPasswd.c_str())) == LIBSSH2_ERROR_EAGAIN)
		{
			waitsocket(m_sock, m_session);
		}
		if (rc)
		{
			snprintf(m_err, 1024,  "Authentication by password failed.\n");
			uninit_session();
			return false;
		}

		return true;
	}

	int init_channel()
	{
		if (m_channel)
		{
			return true;
		}
		if (m_sock == -1)
		{
			snprintf(m_err, 1024, "Socket is not initialized \n");
			return false;
		}
		if (m_session == NULL)
		{
			snprintf(m_err, 1024, "Session is not initialized \n");
			return false;
		}
		while( (m_channel = libssh2_channel_open_session(m_session)) == NULL &&
				           libssh2_session_last_error(m_session, NULL, NULL, 0) == LIBSSH2_ERROR_EAGAIN )
		{
			waitsocket(m_sock, m_session);
		}
		if( m_channel == NULL )
		{
			snprintf(m_err, 1024,"Error\n");
			uninit_channel();
			return false;
		}
		return true;
	}

	void uninit_library()
	{
		if (bInitialized)
		{
			libssh2_exit();
		}
	}

	void uninit_socket()
	{
		if (m_sock!= -1)
		{
			close(m_sock);
			m_sock = -1;
		}
	}

	void uninit_session()
	{
		if (m_session)
		{
			libssh2_session_disconnect(m_session, "Normal Shutdown, Thank you for playing");
			m_session = NULL;
		}
	}
	void uninit_channel()
	{
		if (m_channel)
		{
			if (m_sock != -1 && m_session != NULL)
			{
				while( libssh2_channel_close(m_channel) == LIBSSH2_ERROR_EAGAIN )
				{
					waitsocket(m_sock, m_session);
				}
			}

			libssh2_channel_free(m_channel);
			m_channel = NULL;
		}
	}

	bool do_exec(const string& strCommand, string& strResult)
	{
	    if (init_channel())
        {
	        int rc;
            while( (rc = libssh2_channel_exec(m_channel, strCommand.c_str())) == LIBSSH2_ERROR_EAGAIN )
            {
                waitsocket(m_sock, m_session);
            }
            if( rc != 0 )
            {
                snprintf(m_err, 1024, "Error\n");
                uninit_channel();
                return false;
            }
            char buffer[0x4000];
            while ((rc = libssh2_channel_read(m_channel, buffer, sizeof(buffer))) > 0 || rc == LIBSSH2_ERROR_EAGAIN)
            {
                if( rc > 0 )
                {
                    strResult.append(buffer, rc);
                }
                if( rc == LIBSSH2_ERROR_EAGAIN )
                {
                    waitsocket(m_sock, m_session);
                }
            }
            if (rc == 0)
            {
                char *exitsignal=(char *)"none";
                int exitcode = 127;
                exitcode = libssh2_channel_get_exit_status( m_channel );
                libssh2_channel_get_exit_signal(m_channel, &exitsignal, NULL, NULL, NULL, NULL, NULL);
                if (exitsignal)
                {
                    snprintf(m_err, 1024, "\nGot signal: %s\n", exitsignal);
                }
                else
                {
                    snprintf(m_err, 1024, "\nEXIT: %d\n", exitcode);
                }
                uninit_channel();
                return true;
            }
            snprintf(m_err, 1024, "libssh2_channel_read returned %d\n", rc);
            uninit_channel();
        }
		return false;
	}

	bool init()
	{
	    if (init_library())
        {
            if (init_socket())
            {
                if (init_session())
                {
                    return true;
                }
            }
        }
	    return false;
	}

	~MySSH2()
	{
		uninit_channel();
		uninit_session();
		uninit_socket();
		uninit_library();
	}

	MySSH2(const string& strIp, const string& strUser, const string& strPasswd)
	{
		m_sock = -1;
		m_session = NULL;
		m_channel = NULL;
		bInitialized = false;
		m_strIp = strIp;
		m_strUser = strUser;
		m_strPasswd = strPasswd;
		memset(m_err, 0, sizeof(m_err));
	}
};

int test1()
{
	MySSH2 ssh("192.168.1.115", "nick", "202409");
	string strResult;;
	string strCmd;
	if (ssh.init())
	{
        strCmd = "uname -a";
        strResult.clear();
        if (ssh.do_exec(strCmd, strResult))
        {
            cout << strCmd << ":" << endl << strResult << endl;
        }
        strCmd = "ls -asl";
        strResult.clear();
        if (ssh.do_exec(strCmd, strResult))
        {
           cout << strCmd << ":" << endl << strResult << endl;
        }
        strCmd = "lsb_release -a";
        strResult.clear();
        if (ssh.do_exec(strCmd, strResult))
        {
           cout << strCmd << ":" << endl << strResult << endl;
        }
	}
	return 0;
}

int main(int argc, char** argv)
{
	return test1();
}

debug1: userauth-request for user nick service ssh-connection method publickey [preauth]
debug1: attempt 1 failures 0 [preauth]
debug2: input_userauth_request: try method publickey [preauth]
debug1: test whether pkalg/pkblob are acceptable [preauth]
debug3: mm_key_allowed entering [preauth]
debug3: mm_request_send entering: type 22 [preauth]
debug3: mm_key_allowed: waiting for MONITOR_ANS_KEYALLOWED [preauth]
debug3: mm_request_receive_expect entering: type 23 [preauth]
debug3: mm_request_receive entering [preauth]
debug3: mm_request_receive entering
debug3: monitor_read: checking request 4
debug3: mm_answer_authserv: service=ssh-connection, style=, role=
debug2: monitor_read: 4 used once, disabling now
debug3: mm_request_receive entering
debug3: monitor_read: checking request 22
debug3: mm_answer_keyallowed entering
debug3: mm_answer_keyallowed: key_from_blob: 0x56368a53c2f0
debug1: temporarily_use_uid: 1000/1000 (e=0/0)
debug1: trying public key file /home/nick/.ssh/authorized_keys
debug1: fd 4 clearing O_NONBLOCK
debug1: matching key found: file /home/nick/.ssh/authorized_keys, line 1 RSA eb:a5:e7:59:7d:24:0e:ce:b4:c4:d4:f8:7f:87:d6:d9
debug1: restore_uid: 0/0
debug3: mm_answer_keyallowed: key 0x56368a53c2f0 is allowed
debug3: mm_request_send entering: type 23
debug2: userauth_pubkey: authenticated 0 pkalg ssh-rsa [preauth]
Postponed publickey for nick from 192.168.1.116 port 59340 ssh2 [preauth]

#include <cstdio>
#include <cstdlib>
#include <string>
#include <algorithm>
#include <vector>
#include "libssh2.h"
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <iostream>
#include <pthread.h>
#include "boost/algorithm/string.hpp"


using namespace std;


time_t startTime, endTime;

#define PROFILE_NOW(context) \
  cout <<"&&&&&&&&&"<<context<<"[" << time(&endTime)-startTime<<"]&&&&&&&&&"<<endl;startTime=endTime;

static bool smashInvalidChar (char c)
{
    return !(c>=0 && c <128);
}

class MySSH2
{
private:
    int m_sock;
    LIBSSH2_SESSION *m_session;
    LIBSSH2_CHANNEL *m_channel;
    char m_err[1025];
    string m_strIp;
    string m_strUser;
    string m_strPasswd;
    int m_timeout;
    bool bInitialized;
public:
    int waitsocket(int socket_fd, LIBSSH2_SESSION *session)
    {
        int rc;
        fd_set fd;
        fd_set *writefd = NULL;
        fd_set *readfd = NULL;
        int dir;
        struct timeval timeout;
        timeout.tv_sec = m_timeout;
        timeout.tv_usec = 0;

        FD_ZERO(&fd);
        FD_SET(socket_fd, &fd);
        /* now make sure we wait in the correct direction */
        dir = libssh2_session_block_directions(session);
        if(dir & LIBSSH2_SESSION_BLOCK_INBOUND)
            readfd = &fd;

        if(dir & LIBSSH2_SESSION_BLOCK_OUTBOUND)
            writefd = &fd;

        rc = select(socket_fd + 1, readfd, writefd, NULL, &timeout);
        return rc;
    }

    bool init_library()
    {
        if (libssh2_init(0) == 0)
        {
            cout << "libssh2 version:"<< libssh2_version(1) << endl;
            bInitialized = true;
        }
    }

    bool init_socket()
    {
        if (m_sock != -1)
        {
            return true;
        }
        unsigned long hostaddr;

        struct sockaddr_in sin;

        hostaddr = inet_addr(m_strIp.c_str());

        m_sock = socket(AF_INET, SOCK_STREAM, 0);

        sin.sin_family = AF_INET;
        sin.sin_port = htons(22);
        sin.sin_addr.s_addr = hostaddr;
        if (connect(m_sock, (struct sockaddr*)(&sin),   sizeof(struct sockaddr_in)) != 0)
        {
            snprintf(m_err,1024, "failed to connect!\n");
            uninit_socket();
            return false;
        }
        return true;
    }

    bool init_session()
    {
        if (m_session != NULL)
        {
            return true;
        }
        int rc;
        if (m_sock == -1)
        {
            snprintf(m_err, 1024, "Socket is not initialized \n");
            return false;
        }
        m_session = libssh2_session_init();
        if (!m_session)
        {
            return false;
        }

        /* tell libssh2 we want it all done non-blocking */
        libssh2_session_set_blocking(m_session, 0);
        while ((rc = libssh2_session_handshake(m_session, m_sock)) == LIBSSH2_ERROR_EAGAIN)
        {
            waitsocket(m_sock, m_session);
        }
        if (rc)
        {
            snprintf(m_err, 1024, "Failure establishing SSH session: %d\n", rc);
            uninit_session();
            return false;
        }

        while ((rc = libssh2_userauth_password(m_session, m_strUser.c_str(), m_strPasswd.c_str())) == LIBSSH2_ERROR_EAGAIN)
        {
            waitsocket(m_sock, m_session);
        }
        if (rc)
        {
            snprintf(m_err, 1024,  "Authentication by password failed.\n");
            uninit_session();
            return false;
        }

        return true;
    }

    bool init_channel()
    {
        if (m_channel)
        {
            return true;
        }
        if (m_sock == -1)
        {
            snprintf(m_err, 1024, "Socket is not initialized \n");
            return false;
        }
        if (m_session == NULL)
        {
            snprintf(m_err, 1024, "Session is not initialized \n");
            return false;
        }
        while( (m_channel = libssh2_channel_open_session(m_session)) == NULL &&
                           libssh2_session_last_error(m_session, NULL, NULL, 0) == LIBSSH2_ERROR_EAGAIN )
        {
            waitsocket(m_sock, m_session);
        }
        if( m_channel == NULL )
        {
            snprintf(m_err, 1024,"Error\n");
            uninit_channel();
            return false;
        }
        return true;
    }
    bool init_channel_tty()
    {
        if (m_channel)
        {
            return true;
        }
        if (m_sock == -1)
        {
            snprintf(m_err, 1024, "Socket is not initialized \n");
            return false;
        }
        if (m_session == NULL)
        {
            snprintf(m_err, 1024, "Session is not initialized \n");
            return false;
        }
        while( (m_channel = libssh2_channel_open_session(m_session)) == NULL &&
                           libssh2_session_last_error(m_session, NULL, NULL, 0) == LIBSSH2_ERROR_EAGAIN )
        {
            if (waitsocket(m_sock, m_session) == 0)
            {
                return false;
            }
        }
        if( m_channel == NULL )
        {
            snprintf(m_err, 1024,"Error\n");
            return false;
        }
        while( libssh2_channel_request_pty_ex(m_channel, "vt102",
                (int)strlen("vt102"), NULL, 0,
                LIBSSH2_TERM_WIDTH, LIBSSH2_TERM_HEIGHT,
                LIBSSH2_TERM_WIDTH_PX, LIBSSH2_TERM_HEIGHT_PX) == LIBSSH2_ERROR_EAGAIN)
        {
            if (waitsocket(m_sock, m_session) == 0) // timeout
            {
                return false;
            }
        }
        while(libssh2_channel_shell(m_channel) == LIBSSH2_ERROR_EAGAIN )
        {
            if (waitsocket(m_sock, m_session) == 0)
            {
                return false;
            }
        }
        return true;
    }


    void uninit_library()
    {
        if (bInitialized)
        {
            libssh2_exit();
        }
    }

    void uninit_socket()
    {
        if (m_sock!= -1)
        {
            close(m_sock);
            m_sock = -1;
        }
    }

    void uninit_session()
    {
        if (m_session)
        {
            while (libssh2_session_disconnect(m_session, "Normal Shutdown, Thank you for playing")
                    == LIBSSH2_ERROR_EAGAIN)
            {
                if (waitsocket(m_sock, m_session) == 0)
                {
                   break; // timeout do nothing...
                }
            }
            m_session = NULL;
        }
    }
    void uninit_channel()
    {
        if (m_channel)
        {
            if (m_sock != -1 && m_session != NULL)
            {
                while(libssh2_channel_close(m_channel) == LIBSSH2_ERROR_EAGAIN )
                {
                    if (waitsocket(m_sock, m_session) == 0) // timeout
                    {
                        break;
                    }
                }
            }
            libssh2_channel_free(m_channel);
            m_channel = NULL;
        }
    }
    bool init()
    {
        if (init_library())
        {
            if (init_socket())
            {
                if (init_session())
                {
                    return true;
                }
            }
        }
        return false;
    }

    ~MySSH2()
    {
        uninit_channel();
        uninit_session();
        uninit_socket();
        uninit_library();
    }
    MySSH2(const string& strIp, const string& strUser, const string& strPasswd, int timeOut = 10);

    bool do_exec_tty(const string& strCmd, vector<string>& vResult,
            const string& strExitCond="***********impossibleconditions******************");

};

MySSH2::MySSH2(const string& strIp, const string& strUser, const string& strPasswd, int timeOut)
{
    m_sock = -1;
    m_session = NULL;
    m_channel = NULL;
    bInitialized = false;
    m_strIp = strIp;
    m_strUser = strUser;
    m_strPasswd = strPasswd;
    m_timeout = timeOut;
    memset(m_err, 0, sizeof(m_err));
}

bool MySSH2::do_exec_tty(const string& strCmd, vector<string>& vResult, const string& strExitCond)
{
    bool bResult = false;
    if (init_channel_tty())
    {
        char buffer[2048];
        size_t writeTotal = 0, readTotal = 0;
        int rc = 0;
        int writeNum = 0, readNum = 0;
        bool bWritten = false;
        bool bRead = false;
        string strResult;
        libssh2_channel_receive_window_adjust2(m_channel, sizeof(buffer), 1, NULL);[1]
        do
        {
            // write first
            while (writeTotal < strCmd.size()
                && (writeNum = libssh2_channel_write(m_channel,
                        strCmd.substr(writeTotal).c_str(),
                        strCmd.size()- writeTotal)) > 0
            )
            {
                writeTotal += writeNum;
            }
            // check on error and break
            if (writeNum != LIBSSH2_ERROR_EAGAIN && writeNum <0)
            {
                //log error
                cout << "#######################write error#####################"<< endl;
                break;
            }
            // set write finished
            if (!bWritten && writeTotal>=strCmd.size())
            {
                libssh2_channel_send_eof(m_channel);[2]
                //PROFILE_NOW("write is done");
                bWritten = true;
            }
            // read all the time
            while (readTotal < sizeof(buffer)
                 && (readNum = libssh2_channel_read(m_channel,
                            buffer+readTotal,
                            sizeof(buffer)-readTotal)) > 0
                    )
            {
                //PROFILE_NOW("readNum....");
                cout << "############read number###########"<<readNum<<"########################" << endl;
                // filter unreadable char
                string strSrc(buffer+readTotal, readNum);
                remove_copy_if(strSrc.begin(), strSrc.end(), back_inserter(strResult), smashInvalidChar);

                if (strResult.find(strExitCond) != string::npos)
                {
                    cout << "########find exit condition#############" << endl;
                    bRead = true;
                    break;
                }
                readTotal += readNum;
                // we need to restart a new buffer for reading.
                if (readTotal >= sizeof(buffer))
                {
                    readTotal = 0;
                }
            }
            if (readNum != LIBSSH2_ERROR_EAGAIN && readNum <0)
            {
                // log it
                cout << "#######################read error#####################"<< endl;
                break;
            }
            if (((!bWritten && writeNum == LIBSSH2_ERROR_EAGAIN)// 1. still need to write
                  || bWritten)  // 2. write is done
                    && readNum == LIBSSH2_ERROR_EAGAIN  // 2. reading blocked
                )[4]
            {
                if ((rc = waitsocket(m_sock, m_session)) <= 0)[3]
                {
                    // this means timeout or error!! not necessarilly!!! can be succeed!!!
                    cout << "#######################timeout#####################"<< endl;
                    bResult = true;
                    break;
                }
            }
            // success condition is either meet exit condition or server send EOF to ask us to
            if (bRead || libssh2_channel_eof(m_channel) == 1)
            {
                bResult = true;
                break;
            }
        }
        while (true);
        // will unit channel always
        uninit_channel();
        // now let's process result by filtering and splitting
        if (bResult)
        {
            // split lines into vectors  
          	boost::split(vResult, strResult, boost::is_any_of("\n\r"),boost::token_compress_on);
        }
    }
    return bResult;
}

static void display(const string& strCmd, const vector<string>& vResult)
{
    cout.flush();
    cout << strCmd << ":["<<vResult.size() << "]" << endl;
    cout << "****************************" << endl;
    for (size_t i = 0; i < vResult.size(); i ++)
    {
         cout <<"["<<i<<"]:"<< vResult[i] << endl;
    }
    cout << "****************************" << endl;
    cout.flush();
}

int quanta()
{
    // quanta smash sucks and needs bigger timeout
    MySSH2 ssh("172.17.11.14", "admin", "cmb9.admin", 30);
    vector<string> vResult;;
    string strCmd;
    if (ssh.init())
    {
        strCmd = "help\r\n";
        if (ssh.do_exec_tty(strCmd, vResult))
        {
            display(strCmd, vResult);
        }
        else
        {
            cout << "failed" << endl;
        }

        strCmd = "version\r\n";
        if (ssh.do_exec_tty(strCmd, vResult))
        {
            display(strCmd, vResult);
        }
        else
        {
            cout << "failed" << endl;
        }
    }
    return 0;
}
int linuxSSH()
{
    MySSH2 ssh("172.17.59.177", "root", "Hitachi1");
    vector<string> vResult;;
    string strCmd;
    PROFILE_NOW("test7");
    if (ssh.init())
    {
        strCmd = "lspci\n";
        if (ssh.do_exec_tty(strCmd, vResult))
        {
            display(strCmd, vResult);
        }
        else
        {
            cout << "failed" << endl;
        }
        PROFILE_NOW("lspci");

        strCmd = "find /home\n";
        if (ssh.do_exec_tty(strCmd, vResult))
        {
            display(strCmd, vResult);
        }
        else
        {
            cout << "failed" << endl;
        }
        PROFILE_NOW("find /home");

        strCmd = "lslogins\n";
        if (ssh.do_exec_tty(strCmd, vResult))
        {
            display(strCmd, vResult);
        }
        else
        {
            cout << "failed" << endl;
        }
        PROFILE_NOW("lslogins");
    }
    return 0;
}

int hitachiSmash()
{
    MySSH2 ssh("172.17.59.165", "ceconsl", "cepasswd");
    vector<string> vResult;;
    string strCmd;
    PROFILE_NOW("test8");
    if (ssh.init())
    {
        strCmd = "show chassis setting \r exit \r";
        if (ssh.do_exec_tty(strCmd, vResult, "S0000 : Command was finished."))
        {
            display(strCmd, vResult);
        }
        else
        {
            cout << "failed" << endl;
        }
        PROFILE_NOW("show chassis setting");
        strCmd = "show sw-module mgmt-lan \r exit \r";
        if (ssh.do_exec_tty(strCmd, vResult, "S0000 : Command was finished."))
        {
            display(strCmd, vResult);
        }
        else
        {
            cout << "failed" << endl;
        }
        PROFILE_NOW("show sw-module mgmt-lan");

        strCmd = "show blade hardware 2 -h\r exit \r";
        if (ssh.do_exec_tty(strCmd, vResult, "S0000 : Command was finished."))
        {
            display(strCmd, vResult);
        }
        else
        {
            cout << "failed" << endl;
        }
        PROFILE_NOW("show blade hardware 2");
        strCmd = "show blade firmware 2 \r exit \r";
        if (ssh.do_exec_tty(strCmd, vResult, "S0000 : Command was finished."))
        {
            display(strCmd, vResult);
        }
        else
        {
            cout << "failed" << endl;
        }
        PROFILE_NOW("show blade firmware  2");
    }
    return 0;
}

int main(int argc, char** argv)
{
    quanta();
    hitachiSmash();
    linuxSSH();
    return 0;
}

• _{[1]。实际上我也不确定这个是否总是有效，似乎很多时候不起作用。比如hitachi smash就似乎没有效果。}
• 。_{[2]实际上根据ssh的协议这个不是强制的，这也就是为什么我们监听libssh2_channel_eof会经常没有结果的原因，这也是为什么我们一定需要timeout的原因，同时针对特殊系统只能搜索特定的字串以便早些退出。}
• _{[3]。为什么这个就是timeout呢？因为select的返回值是正数就是指的有filedescriptor有内容，只有0才是因为timeout的返回。}
• _[4]。为什么要使用这个条件来选择waitsocket呢？因为我想尽量不被堵塞，也就是说只有当读写两个方向都被堵塞的时候，或者说当写已经完成了我们才选择等待，这样子应该是效率最高的。

libssh2 version:1.4.3-20120709

############read number###########8########################

############read number###########45########################

############read number###########8########################

############read number###########24########################

############read number###########2########################

############read number###########2########################

############read number###########18########################

############read number###########364########################

#######################timeout#####################

help

 

:[16]

****************************

[0]:help

[1]:[2J[H

[2]:                                         >> SMASHLITE Scorpio Console <<

[3]:->help

[4]:COMMAND COMPLETED : help

[5]:Command Name: help

[6]:Used to get help on commands and targets

[7]:Usage: help [-options]

[8]:Options:

[9]:         examine - used to examine the command (bypasses executer)

[10]:       help - shows help on how to use help

[11]:       output - formats the output string (should be used with format (text,clpcsv,keyword,clpxml)

[12]:                                                       like help -output format=keyword

[13]:       version - shows the smash version

[14]:->

[15]:->

****************************

############read number###########11########################

############read number###########45########################

############read number###########2########################

############read number###########1########################

############read number###########1########################

############read number###########1########################

############read number###########1########################

############read number###########1########################

############read number###########1########################

############read number###########195########################

#######################timeout#####################

version

 

:[10]

****************************

[0]:version

[1]:[2J[H

[2]:                                         >> SMASHLITE Scorpio Console <<

[3]:->version

[4]:COMMAND COMPLETED : version

[5]:*****************************************************

[6]:Smash CLP Version :SMASH 1.0.0/CLP 1.09

[7]:*****************************************************

[8]:->

[9]:->

****************************

&&&&&&&&&test8[1520389566]&&&&&&&&&

libssh2 version:1.4.3-20120709

############read number###########31########################

############read number###########189########################

############read number###########41########################

############read number###########119########################

############read number###########329########################

############read number###########55########################

############read number###########282########################

########find exit condition#############

show chassis setting

 exit

:[30]

****************************

[0]:show chassis setting

[1]: exit

[2]:[H[JHitachi Compute Blade 2500 Management Module

[3]:ALL RIGHTS RESERVED, COPYRIGHT (C) 2014,2016, HITACHI, LTD.

[4]:Chassis ID        : chassis59_165      

[5]:Firmware Revision : A0160-B-1453

[6]:chassis59_165(1)$ show chassis setting

[7]:-- chassis setting --

[8]:Chassis ID                     : chassis59_165      

[9]:Maintenance classification     : normal

[10]:WDT time-out N+M failover      : disable

[11]:-- chassis FRU setting --

[12]:Part/model number              : GG-RE4A1UBX1-Y                 

[13]:Serial number                  :                           

[14]:Model ID                       : 00

[15]:Midplane ID                    : 00

[16]:First WWN                      : 0102000000000000000000

[17]:-- Weight --

[18]:Weight [kg]                    : 120.47

[19]:-- chassis sensor information --

[20]:-- Watt --

[21]:PresentAC Power                : 433

[22]:PresentDC Power                : 372

[23]:-- Temp --

[24]:Present Ambient                : 22

[25]:-- Flow --

[26]:PresentAir Flow                : 10.21

[27]:S0002 : Command succeeded.

[28]:S0000 : Command was finished.

[29]:

****************************

&&&&&&&&&show chassis setting[4]&&&&&&&&&

############read number###########34########################

############read number###########189########################

############read number###########44########################

############read number###########383########################

########find exit condition#############

show sw-module mgmt-lan

 exit

:[20]

****************************

[0]:show sw-module mgmt-lan

[1]: exit

[2]:[H[JHitachi Compute Blade 2500 Management Module

[3]:ALL RIGHTS RESERVED, COPYRIGHT (C) 2014,2016, HITACHI, LTD.

[4]:Chassis ID        : chassis59_165      

[5]:Firmware Revision : A0160-B-1453

[6]:chassis59_165(1)$ show sw-module mgmt-lan

[7]:-- Switch module management LAN setting --

[8]:Slot            : 1

[9]:IP address      : 172.17.59.163

[10]:Subnetmask      : 255.255.255.0

[11]:Default gateway : 172.17.59.1

[12]:-- Switch module management LAN setting --

[13]:Slot            : 2

[14]:IP address      : 172.17.59.164

[15]:Subnetmask      : 255.255.255.0

[16]:Default gateway : 172.17.59.1

[17]:S0002 : Command succeeded.

[18]:S0000 : Command was finished.

[19]:

****************************

&&&&&&&&&show sw-module mgmt-lan[3]&&&&&&&&&

############read number###########34########################

############read number###########189########################

############read number###########44########################

############read number###########1229########################

############read number###########251########################

############read number###########241########################

############read number###########60########################

############read number###########10########################

############read number###########59########################

########find exit condition#############

show blade hardware 2 -h

exit

:[48]

****************************

[0]:show blade hardware 2 -h

[1]: exit

[2]:[H[JHitachi Compute Blade 2500 Management Module

[3]:ALL RIGHTS RESERVED, COPYRIGHT (C) 2014,2016, HITACHI, LTD.

[4]:Chassis ID        : chassis59_165      

[5]:Firmware Revision : A0160-B-1453

[6]:chassis59_165(1)$ show blade hardware 2 -h

[7]:-- Server blade hardware information --

[8]:Slot                                      : 2

[9]:-- Server blade --

[10]:Product name                              : Compute Blade 520HB4

[11]:Model name                                : GG-RV3XGC0B4X1-Y               

[12]:Serial number                             : 323GG-RV3XGC0B4X1-Y00000087

[13]:-- CPU --

[14]:Name                                      : Intel(R) Xeon(R) CPU E5-2690 v4 @ 2.60GHz

[15]:Installed                                 : 2

[16]:Slots                                     : 2

[17]:-- Memory --

[18]:Memory [MB]                               : 131072

[19]:-- I/O card --

[20]:Mezzanine 1                               : -----

[21]:Mezzanine 2                               : PCI Express Adapter Connection Mezzanine Card

[22]:PCI 0                                     : -----

[23]:PCI 1                                     : -----

[24]:Daughter card 0                           : -----

[25]:-- OnBoard LAN 1 --

[26]:Type                                      : 10Gb Onboard LAN

[27]:LOM#1 MAC for Port#0                      : f8:48:97:aa:19:f0

[28]:LOM#1 MAC for Port#1                      : f8:48:97:aa:19:f4

[29]:LOM#1 MAC for Port#2                      : f8:48:97:aa:19:f8

[30]:LOM#1 MAC for Port#3                      : f8:48:97:aa:19:fc

[31]:-- LP license --

[32]:LP model                                  : Essential

[33]:Upper bound of version                    : -----

[34]:-- Power --

[35]:Nameplate power [W]                       : 429

[36]:-- Weight --

[37]:Weight [kg]                               : 7.100

[38]:-- UUID --

[39]:UUID                                      : 3d040dd2-e2ce-11e5-93b1-9521be8ac651

[40]:-- BMC MAC address --

[41]:BMC MAC address 0                         : f8:48:97:ca:58:00

[42]:BMC MAC address 1                         : f8:48:97:ca:58:01

[43]:-- LOM type --

[44]:LOM                                       : enable

[45]:S0002 : Command succeeded.

[46]:S0000 : Command was finished.

[47]:

****************************

&&&&&&&&&show blade hardware 2[4]&&&&&&&&&

############read number###########32########################

############read number###########189########################

############read number###########42########################

############read number###########568########################

########find exit condition#############

show blade firmware 2

 exit

:[26]

****************************

[0]:show blade firmware 2

[1]: exit

[2]:[H[JHitachi Compute Blade 2500 Management Module

[3]:ALL RIGHTS RESERVED, COPYRIGHT (C) 2014,2016, HITACHI, LTD.

[4]:Chassis ID        : chassis59_165      

[5]:Firmware Revision : A0160-B-1453

[6]:chassis59_165(1)$ show blade firmware 2

[7]:-- Server blade firmware version --

[8]:Slot                      : 2

[9]:-- Total version --

[10]:Current version           : 10-02(03)

[11]:Next version              : -----

[12]:-- BMC version --

[13]:Current version           : 10-02(00)

[14]:Next version              : -----

[15]:-- EFI version --

[16]:Current version           : 10-02(03)

[17]:Next version              : -----

[18]:-- HVM firmware --

[19]:Current version           : -----

[20]:Current bank              : -----

[21]:Next version              : -----

[22]:Next bank                 : -----

[23]:S0002 : Command succeeded.

[24]:S0000 : Command was finished.

[25]:

****************************

&&&&&&&&&show blade firmware  2[3]&&&&&&&&&

&&&&&&&&&test7[0]&&&&&&&&&

libssh2 version:1.4.3-20120709

############read number###########58########################

############read number###########7########################

############read number###########30########################

############read number###########1953########################

############read number###########728########################

#######################timeout#####################

lspci

:[46]

****************************

[0]:Last login: Tue Mar  6 19:05:47 2018 from 172.17.58.110

[1]:lspci

[2]:[root@OEL72-59-177 ~]# lspci

[3]:00:00.0 Host bridge: Intel Corporation 440BX/ZX/DX - 82443BX/ZX/DX Host bridge (rev 01)

[4]:00:01.0 PCI bridge: Intel Corporation 440BX/ZX/DX - 82443BX/ZX/DX AGP bridge (rev 01)

[5]:00:07.0 ISA bridge: Intel Corporation 82371AB/EB/MB PIIX4 ISA (rev 08)

[6]:00:07.1 IDE interface: Intel Corporation 82371AB/EB/MB PIIX4 IDE (rev 01)

[7]:00:07.3 Bridge: Intel Corporation 82371AB/EB/MB PIIX4 ACPI (rev 08)

[8]:00:07.7 System peripheral: VMware Virtual Machine Communication Interface (rev 10)

[9]:00:0f.0 VGA compatible controller: VMware SVGA II Adapter

[10]:00:10.0 SCSI storage controller: LSI Logic / Symbios Logic 53c1030 PCI-X Fusion-MPT Dual Ultra320 SCSI (rev 01)

[11]:00:11.0 PCI bridge: VMware PCI bridge (rev 02)

[12]:00:15.0 PCI bridge: VMware PCI Express Root Port (rev 01)

[13]:00:15.1 PCI bridge: VMware PCI Express Root Port (rev 01)

[14]:00:15.2 PCI bridge: VMware PCI Express Root Port (rev 01)

[15]:00:15.3 PCI bridge: VMware PCI Express Root Port (rev 01)

[16]:00:15.4 PCI bridge: VMware PCI Express Root Port (rev 01)

[17]:00:15.5 PCI bridge: VMware PCI Express Root Port (rev 01)

[18]:00:15.6 PCI bridge: VMware PCI Express Root Port (rev 01)

[19]:00:15.7 PCI bridge: VMware PCI Express Root Port (rev 01)

[20]:00:16.0 PCI bridge: VMware PCI Express Root Port (rev 01)

[21]:00:16.1 PCI bridge: VMware PCI Express Root Port (rev 01)

[22]:00:16.2 PCI bridge: VMware PCI Express Root Port (rev 01)

[23]:00:16.3 PCI bridge: VMware PCI Express Root Port (rev 01)

[24]:00:16.4 PCI bridge: VMware PCI Express Root Port (rev 01)

[25]:00:16.5 PCI bridge: VMware PCI Express Root Port (rev 01)

[26]:00:16.6 PCI bridge: VMware PCI Express Root Port (rev 01)

[27]:00:16.7 PCI bridge: VMware PCI Express Root Port (rev 01)

[28]:00:17.0 PCI bridge: VMware PCI Express Root Port (rev 01)

[29]:00:17.1 PCI bridge: VMware PCI Express Root Port (rev 01)

[30]:00:17.2 PCI bridge: VMware PCI Express Root Port (rev 01)

[31]:00:17.3 PCI bridge: VMware PCI Express Root Port (rev 01)

[32]:00:17.4 PCI bridge: VMware PCI Express Root Port (rev 01)

[33]:00:17.5 PCI bridge: VMware PCI Express Root Port (rev 01)

[34]:00:17.6 PCI bridge: VMware PCI Express Root Port (rev 01)

[35]:00:17.7 PCI bridge: VMware PCI Express Root Port (rev 01)

[36]:00:18.0 PCI bridge: VMware PCI Express Root Port (rev 01)

[37]:00:18.1 PCI bridge: VMware PCI Express Root Port (rev 01)

[38]:00:18.2 PCI bridge: VMware PCI Express Root Port (rev 01)

[39]:00:18.3 PCI bridge: VMware PCI Express Root Port (rev 01)

[40]:00:18.4 PCI bridge: VMware PCI Express Root Port (rev 01)

[41]:00:18.5 PCI bridge: VMware PCI Express Root Port (rev 01)

[42]:00:18.6 PCI bridge: VMware PCI Express Root Port (rev 01)

[43]:00:18.7 PCI bridge: VMware PCI Express Root Port (rev 01)

[44]:03:00.0 Ethernet controller: VMware VMXNET3 Ethernet Controller (rev 01)

[45]:[root@OEL72-59-177 ~]#

****************************

&&&&&&&&&lspci[12]&&&&&&&&&

############read number###########58########################

############read number###########12########################

############read number###########35########################

############read number###########260########################

#######################timeout#####################

find /home

:[14]

****************************

[0]:Last login: Tue Mar  6 19:11:59 2018 from 172.17.58.110

[1]:find /home

[2]:[root@OEL72-59-177 ~]# find /home

[3]:/home

[4]:/home/nick-obj-rep-59-228-exp

[5]:/home/razor

[6]:/home/razor/.bash_logout

[7]:/home/razor/.bash_profile

[8]:/home/razor/.bashrc

[9]:/home/razor/.mozilla

[10]:/home/razor/.mozilla/extensions

[11]:/home/razor/.mozilla/plugins

[12]:/home/razor/.bash_history

[13]:[root@OEL72-59-177 ~]#

****************************

&&&&&&&&&find /home[10]&&&&&&&&&

############read number###########58########################

############read number###########10########################

############read number###########33########################

############read number###########1947########################

############read number###########930########################

#######################timeout#####################

lslogins

:[53]

****************************

[0]:Last login: Tue Mar  6 19:12:09 2018 from 172.17.58.110

[1]:lslogins

[2]:[root@OEL72-59-177 ~]# lslogins

[3]:  UID USER      PROC PWD-LOCK PWD-DENY LAST-LOGIN GECOS

[4]:    0 root       158        0        0   19:12:20 root

[5]:    1 bin          0        0        1            bin

[6]:    2 daemon       0        0        1            daemon

[7]:    3 adm          0        0        1            adm

[8]:    4 lp           0        0        1            lp

[9]:    5 sync         0        0        1            sync

[10]:    6 shutdown     0        0        1 2017-Mar15 shutdown

[11]:    7 halt         0        0        1            halt

[12]:    8 mail         0        0        1            mail

[13]:   11 operator     0        0        1            operator

[14]:   12 games        0        0        1            games

[15]:   14 ftp          0        0        1            FTP User

[16]:   26 postgres     7        0        1            PostgreSQL Server

[17]:   29 rpcuser      0        0        1            RPC Service User

[18]:   32 rpc          0        0        1            Rpcbind Daemon

[19]:   38 ntp          0        0        1           

[20]:   42 gdm          0        0        1           

[21]:   59 tss          0        0        1            Account used by the trousers p

[22]:   70 avahi        0        0        1            Avahi mDNS/DNS-SD Stack

[23]:   74 sshd         0        0        1            Privilege-separated SSH

[24]:   75 radvd        0        0        1            radvd user

[25]:   81 dbus         0        0        1            System message bus

[26]:   89 postfix      1        0        1           

[27]:   99 nobody       0        0        1            Nobody

[28]:  107 qemu         0        0        1            qemu user

[29]:  113 usbmuxd      0        0        1            usbmuxd user

[30]:  170 avahi-autoipd

[31]:                   0        0        1            Avahi IPv4LL Stack

[32]:  171 pulse        0        0        1            PulseAudio System Daemon

[33]:  172 rtkit        0        0        1            RealtimeKit

[34]:  173 abrt         0        0        1           

[35]:  177 dhcpd        0        0        1            DHCP server

[36]:  990 gnome-initial-setup

[37]:                   0        0        1           

[38]:  991 unbound      0        0        1            Unbound DNS resolver

[39]:  992 colord       0        0        1            User for colord

[40]:  993 setroubleshoot

[41]:                   0        0        1           

[42]:  994 saslauth     0        0        1            Saslauthd user

[43]:  995 chrony       0        0        1           

[44]:  996 geoclue      0        0        1            User for geoclue

[45]:  997 polkitd      0        0        1            User for polkitd

[46]:  998 systemd-network

[47]:                   0        0        1            systemd Network Management

[48]:  999 systemd-bus-proxy

[49]:                   0        0        1            systemd Bus Proxy

[50]: 1000 razor        0        0        0           

[51]:65534 nfsnobody    0        0        1            Anonymous NFS User

[52]:[root@OEL72-59-177 ~]#

****************************

&&&&&&&&&lslogins[10]&&&&&&&&&

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <openssl/evp.h>
#include <openssl/rsa.h>
#include <openssl/err.h>
#include <openssl/bio.h>


#define HANDLE_ERR(func)\
    printf("%s[%d]: %s\n", #func, __LINE__, ERR_reason_error_string(ERR_get_error())); goto clear;

#define HANDLE_FAIL(func)\
    printf("%s[%d]: %s\n", #func, __LINE__, ERR_reason_error_string(ERR_get_error()));continue;

int main()
{
    ERR_load_crypto_strings();
    EVP_PKEY_CTX *ctx = NULL;
    BIO* bio = NULL;
    EVP_PKEY *pkey = NULL;
    int result = -1;
    bio = BIO_new_fp(stdout, BIO_NOCLOSE);
    if (bio == NULL)
    {
        HANDLE_ERR(bio);
    }
    pkey = EVP_PKEY_new();
    if (pkey == NULL)
    {
        HANDLE_ERR(EVP_PKEY_new);
    }
    int algoArray[] = {EVP_PKEY_RSA, EVP_PKEY_RSA2, EVP_PKEY_DSA, EVP_PKEY_DSA1, EVP_PKEY_DSA2,
                    EVP_PKEY_DSA3, EVP_PKEY_DSA4, EVP_PKEY_DH, EVP_PKEY_EC};

    for (int algo = 0; algo < sizeof(algoArray)/sizeof(algoArray[0]); algo++)
    {
        if (ctx)
        {
            EVP_PKEY_CTX_free(ctx);
            ctx = NULL;
        }
        ctx = EVP_PKEY_CTX_new_id(algoArray[algo], NULL);
        if (!ctx)
        {
            HANDLE_FAIL(EVP_PKEY_CTX_new);
        }
        if (EVP_PKEY_keygen_init(ctx) <= 0)
        {
            HANDLE_FAIL(EVP_PKEY_keygen_init);
        }
        const EVP_MD * mdArray[] = {EVP_sha(), EVP_sha1(),EVP_sha224(), EVP_sha256(), EVP_sha384(), EVP_sha512()};

        for (int md = 0; md < sizeof(mdArray)/sizeof(mdArray[0]); md ++)
        {
            if (EVP_PKEY_CTX_ctrl(ctx, algoArray[algo],EVP_PKEY_OP_KEYGEN, EVP_PKEY_CTRL_MD, 0, (void*)mdArray[md])<=0)
            {
                HANDLE_FAIL(EVP_PKEY_CTX_ctrl);
            }
            int bitsArray[] = {256, 1024, 2048, 4096};
            for (int bits = 0; bits < sizeof(bitsArray)/sizeof(bitsArray[0]); bits ++)
            {
                if (EVP_PKEY_CTX_ctrl(ctx, algoArray[algo],EVP_PKEY_OP_KEYGEN,EVP_PKEY_CTRL_RSA_KEYGEN_BITS, bitsArray[bits], NULL)<=0)
                {
                    HANDLE_FAIL(EVP_PKEY_CTX_ctrl);
                }
                int padArray[]={RSA_PKCS1_PADDING, RSA_SSLV23_PADDING, RSA_PKCS1_OAEP_PADDING, RSA_X931_PADDING, RSA_PKCS1_PSS_PADDING};
                for (int pad = 0; pad<= sizeof(padArray)/sizeof(padArray[0]); pad++)
                {
                    if (EVP_PKEY_CTX_ctrl(ctx, algoArray[algo],EVP_PKEY_OP_KEYGEN,EVP_PKEY_CTRL_RSA_PADDING, padArray[pad], NULL)<=0)
                    {
                        HANDLE_FAIL(EVP_PKEY_CTX_ctrl);
                    }
                    if (EVP_PKEY_keygen(ctx, &pkey)<=0)
                    {
                        HANDLE_FAIL(EVP_PKEY_keygen);
                    }
                    BIO_printf(bio, "success: algoArray[%d]mdArray[%d]bitsArray[%d]padArraypadArray[%d]\n",
                               algo, md, bits, pad);;
                }
            }
        }
    }


clear:
if (bio)
{
    BIO_free(bio);
}
if (pkey)
{
    EVP_PKEY_free(pkey);
}
if (ctx)
{
    EVP_PKEY_CTX_free(ctx);
}
    return 0;
}

#!/bin/bash

season=2

for var in `find /media/nick -type f -name "VTS_*.VOB" -size +1M`
do
index=`echo ${var}|grep -Eo '([0-9_]{5})'`
hasSub=`ffmpeg -i ${var} -c copy -map 0:s -f null - -v 0 -hide_banner && echo $? || echo $?`
if [ ${hasSub} == 0 ]; 
then `ffmpeg -y -i ${var} -vcodec h264 -acodec aac -max_muxing_queue_size 999 -filter_complex "[0:v][0:s]overlay" /home/nick/volume1/video/guild/season${season}/video${index}.mp4`
else `ffmpeg -y -i ${var} -vcodec h264 -acodec aac -max_muxing_queue_size 999 /home/nick/volume1/video/guild/season${season}/video${index}.mp4`
fi 
done

files=$(find . -name "VTS_*.VOB" -printf '"%h/%f" ');for f in "$files"; do echo "${f}"; done

The empty string for the delimiter means 'use the zero byte, ASCII NUL, as the delimiter' and is appropriate for parsing 'find ... -print0' output.

find . -name "VTS_*.VOB" -type f| while read -d '' file;
do echo "<<$file>>"; done

for title in {2..25}; 
do 
./HandBrakeCLI -e x264 -E av_aac -i /dev/sr0 -o ~/volume1/video/guild/season3/video_title_${title}.mp4 -Z "High Profile" -s 1 --subtitle-burned 1 --subtitle-default 1 -t ${title}; 
done

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <openssl/evp.h>
#include <openssl/rsa.h>
#include <openssl/err.h>
#include <openssl/bio.h>

#define HANDLE_ERR(func)\
    printf("%s[%d]: %s\n", #func, __LINE__, ERR_reason_error_string(ERR_get_error())); goto clear;

#define HANDLE_FAIL(func)\
    printf("%s[%d]: %s\n", #func, __LINE__, ERR_reason_error_string(ERR_get_error()));continue;

void keyTest(const unsigned char* msg, unsigned int nsize, unsigned char* retBuf, unsigned int* retsize)
{
    ERR_load_crypto_strings();
    int nmethod = NID_md5_sha1;
    BIO* bio = NULL;
    BIGNUM *bn = NULL;
    RSA* rsa = NULL;
    int nbits = 1024;
    bio = BIO_new_fp(stdout, BIO_NOCLOSE);
    if (bio==NULL)
    {
        HANDLE_ERR(BIO_new);
    }
    rsa = RSA_new_method(NULL);
    if (rsa == NULL)
    {
        HANDLE_ERR(RSA_new);
    }
    bn = BN_new();
    if (bn == NULL)
    {
        HANDLE_ERR(BN_new);
    }
    if (BN_set_word(bn, RSA_F4)<=0)[1]
    {
        HANDLE_ERR(BN_set_word);
    }
    if (RSA_generate_key_ex(rsa, nbits, bn, NULL)<=0)[2]
    {
        HANDLE_ERR(RSA_generate_key_ex);
    }

    if (RSA_check_key(rsa)<=0)
    {
        HANDLE_ERR(RSA_check_key);
    }

    if (RSA_print(bio, rsa, 4)<=0)
    {
        HANDLE_ERR(RSA_print);
    }

    if (RSA_sign(nmethod, msg, nsize, retBuf, retsize, rsa) <= 0)
    {
        HANDLE_ERR(RSA_sign);
    }

    if (RSA_verify(nmethod, msg, nsize, retBuf, *retsize, rsa) <= 0)
    {
        HANDLE_ERR(RSA_verify);
    }

clear:
    if (bio)
    {
        BIO_free(bio);
    }
    if (bn)
    {
        BN_free(bn);
    }
    if (rsa)
    {
        RSA_free(rsa);
    }
}

int main()
{
    unsigned char msg[36];[3]
    unsigned char buf[256];
    int size = sizeof(buf);
    for (size_t i = 0; i < sizeof(msg); i++)
    {
        msg[i] = i;
    }
    keyTest(msg, sizeof(msg), buf, &size);
    printf("size: %u\n", size);
    for (size_t i = 0; i < size; i ++)
    {
        printf("%02X", buf[i]);
    }
    return 0;
}

1. _{[1]:这个很关键，之前我不知道创建这个参数的意义，结果我也成功的产生了所谓的key，这个隐藏的很深，只有在verify的时候才发现这个错误。}
2. _{[2]:这个就是我在上面提到的问题，对于这个参数的理解很重要，它就是一个类型RSA_F4。}
3. _{[3]:这个也很重要的，这个sign的message的size只能是36，这个是针对md5_sha1的类型，我的猜想是16+20，前者是md5，后者是sha1，但是我不明白md5是什么的digest。同样的sign之后的size是128。}

#include <iostream>
#include <fstream>
#include <sstream>
#include <cstring>
#include <cstdlib>
#include <vector>
#include <htmlcxx/html/ParserDom.h>
#include <sys/dir.h>
using namespace std;
using namespace htmlcxx::HTML;

bool getString(const string& strFile, string& strContent)
{
    ifstream ifs(strFile.c_str(), ifstream::in);
    if (ifs.good())
    {
        stringstream ss;
        ss << ifs.rdbuf();
        strContent = ss.str();
        return true;
    }
    return false;
}

bool setString(const string& strFile, const string& strContent)
{
    ofstream ofs(strFile.c_str(), ifstream::out|ifstream::trunc);
    if (ofs.good())
    {
        ofs<< strContent;
        return true;
    }
    return false;
}

bool addAds(const string& strFile, const string& strAds)
{
    string strContent;
    if (getString(strFile, strContent))
    {
        ParserDom dom;
        const tree<Node>& tr = dom.parseTree(strContent);
        for (tree<Node>::pre_order_iterator it = tr.begin(); it != tr.end(); it++)
        {
            if (it->isTag() && it->tagName().compare("head") == 0)
            {
                size_t pos = strContent.find_first_of('>', it->offset());
                if (pos != string::npos)
                {
                    if (strContent.substr(pos+1, strAds.size()).compare(strAds) != 0)
                    {
                        strContent.insert(pos+1, strAds);
                        return setString(strFile, strContent);
                    }
                }
            }
        }
    }
    return false;
}

bool removeAds(const string& strFile, const string& strAds)
{
    string strContent;
    if (getString(strFile, strContent))
    {
        ParserDom dom;
        const tree<Node>& tr = dom.parseTree(strContent);
        for (tree<Node>::pre_order_iterator it = tr.begin(); it != tr.end(); it++)
        {
            if (it->isTag() && it->tagName().compare("head") == 0)
            {
                size_t pos = strContent.find_first_of('>', it->offset());
                if (pos != string::npos)
                {
                    if (strContent.substr(pos+1, strAds.size()).compare(strAds) == 0)
                    {
                        strContent.erase(pos+1, strAds.size());
                        return setString(strFile, strContent);
                    }
                }
            }
        }
    }
    return false;
}

bool isHtml(const string& strName)
{
    size_t pos = strName.find_last_of('.');
    if (pos != string::npos)
    {
        const string& strExt = strName.substr(pos+1);
        if (strcasecmp(strExt.c_str(), "html") == 0 || strcasecmp(strExt.c_str(), "htm") == 0)
        {
            return true;
        }
    }
    return false;
}
bool isForbidden(const string& strDir)
{
    if (strDir.compare("personal") == 0 || strDir.compare("generatedTrees") == 0)
    {
        return true;
    }
    return false;
}

bool doGetAllFiles(const string& strPath, vector<string>& vect)
{
    DIR *dir;
    if ((dir = opendir(strPath.c_str())) != NULL)
    {
        struct dirent *ent;
        while ((ent = readdir(dir)) != NULL)
        {
            switch (ent->d_type)
            {
            case DT_DIR:
                if (strcmp(ent->d_name, ".") != 0 && strcmp(ent->d_name, "..") != 0)
                {
                    if (!isForbidden(ent->d_name))
                    {
                        if (!doGetAllFiles(strPath+"/"+ ent->d_name, vect))
                        {
                            return false;
                        }
                    }
                }
                break;
            case DT_REG:
                if (isHtml(ent->d_name))
                {
                    vect.push_back(strPath+"/"+ent->d_name);
                }
                break;
            default:
                break;
            }
        }
        closedir(dir);
    }
    else
    {
        perror (strPath.c_str());
        return false;
    }
    return true;
}

bool getAllFiles(const string& strPath, vector<string>& vect)
{
    char path[PATH_MAX+1];
    if (realpath(strPath.c_str(), path))
    {
        return doGetAllFiles(path, vect);
    }
    return false;
}

bool doSearchAds(const string& strFile)
{
    string strContent;
    if (getString(strFile, strContent))
    {
        ParserDom dom;
        const tree<Node>& tr = dom.parseTree(strContent);
        for (tree<Node>::pre_order_iterator it = tr.begin(); it != tr.end(); it++)
        {
            if (it->isTag() && it->tagName().compare("script") == 0)
            {
                if (it->text().find("google")!= string::npos)
                {
                    cout << "filename:"<< strFile << " text:" << it->text() << endl;
                }

            }
        }
    }
    return false;
}

bool doSearchAllFiles(const string& strPath)
{
    DIR *dir;
    if ((dir = opendir(strPath.c_str())) != NULL)
    {
        struct dirent *ent;

        while ((ent = readdir(dir)) != NULL)
        {
            string strNewPath = strPath+"/" + ent->d_name;
            switch (ent->d_type)
            {
            case DT_DIR:
                if (strcmp(ent->d_name, ".") != 0 && strcmp(ent->d_name, "..") != 0)
                {
                    if (!isForbidden(ent->d_name))
                    {
                        if (!doSearchAllFiles(strNewPath))
                        {
                            return false;
                        }
                    }
                }
                break;
            case DT_REG:
                if (isHtml(ent->d_name))
                {
                    doSearchAds(strNewPath);
                }
                break;
            default:
                break;
            }
        }
        closedir(dir);
    }
    else
    {
        perror (strPath.c_str());
        return false;
    }
    return true;
}

bool searchAds(const string& strPath)
{
    char path[PATH_MAX+1];
    if (realpath(strPath.c_str(), path))
    {
        return doSearchAllFiles(path);
    }
    return false;
}

bool test2(const string& strPath)
{
    vector<string> vect;
    if (getAllFiles(strPath, vect))
    {
        for (size_t i =0; i < vect.size(); i ++)
        {
            cout << vect[i] << endl;
        }
        cout << "total file number: " << vect.size() << endl;
        return true;
    }
    return false;
}

bool test1(const string& strFileName)
{
    const string strAdsFile="/home/nick/googleads.txt";
    string strAds;
    string strOldContent, strNewContent;
    if (getString(strAdsFile, strAds))
    {
        if (getString(strFileName, strOldContent))
        {
            if (addAds(strFileName, strAds))
            {
                if (removeAds(strFileName, strAds))
                {
                    if (getString(strFileName, strNewContent))
                    {
                       if (strOldContent.compare(strNewContent) == 0)
                       {
                           cout << "content remain unchanged" << endl;
                           return true;
                       }
                    }
                }
            }
        }
    }
    return false;
}

bool test3(const string& strFileName)
{
    const string strAdsFile="/home/nick/googleads.txt";
    string strAds;
    string strOldContent, strNewContent;
    if (getString(strAdsFile, strAds))
    {
        if (getString(strFileName, strOldContent))
        {
            if (addAds(strFileName, strAds))
            {
                if (removeAds(strFileName, strAds))
                {
                    if (getString(strFileName, strNewContent))
                    {
                       if (strOldContent.compare(strNewContent) == 0)
                       {
                           cout << "content remain unchanged" << endl;
                           return true;
                       }
                    }
                }
            }
        }
    }
    return false;
}

int myAddAds(const string& strPath, const string& strAdsFile)
{
    int result = 0;
    string strAds;
    if (getString(strAdsFile, strAds))
    {
        vector<string> vect;
        if (getAllFiles(strPath, vect))
        {
            for (size_t i =0; i < vect.size(); i ++)
            {
                if (addAds(vect[i], strAds))
                {
                    cout << vect[i] << endl;
                    result ++;
                }
            }
        }
    }
    return result;
}

int main(int argc, char** argv)
{
    if (argc != 3)
    {
        cout << "usage: " << argv[0] << " <diabloPath> <googleads>" << endl;
        return -1;
    }
    cout << myAddAds(argv[1], argv[2]) << endl;
    return 0;
}

1. 首先，是在readdir的manpage就明确说了不是所有的文件系统都实现了这个type，这个是作为一般的开发者应有的素质要自己处理这个问题。
2. 其次，这个问题的核心是为什么。原因是很深层次的效率问题，我可以理解不把type信息存在directory里，可是到底是为什么？难道一个byte的type是如此的庞大吗？以下这部分的高亮部分我还是不能理解_{难道我的英语真的有问题，因为如果在每一个directory里把每一个包含的子目录文件的属性存储下来难道你不需要读取所有的成员的inode来查询吗？这个工作不应该是ls之类的文件夹阅读者的工作吗？为什么要文件夹来保管？你保存了属性也许还有贪心者要你保存inode相关的其他信息这个不是endless game吗？}：是不是可以这么理解dirent这个结构为了存储效率和其他原因不保存自己的_{当然不是自己的，自己就是directory需要的是包含的每个子节点的信息，我可能脑子不清楚}type信息，因为有了inode用户自己去查询。这个从实现者的角度来看似乎更有理由。首先是冗余信息的存储，而且这个牵连到修改文件的一致性的问题因为冗余的数据就意味着修改的麻烦。其次我以为文件的所有的信息都应该和其inode联系而文件夹的职责是一个考量，它仅仅是一个容器存储的是一个与文件系统实现无关的所包含的子节点的信息，这句话要这么说，所谓字节点就是它所包含的文件和子目录，那么与实现无关的就是他们的文件名和子目录名。从这一点来理解就是文件夹和软连接一样都是一种特殊的文件，一个内容是包含的文件名，一个内容是它指向的目标的路径。只有名字是和平台实现无关的最无争议的部分。甚至于inode的任何信息都是一个包含了实现细节的累赘。这些实际上是在stat的manpage里讲的很多。这个就是真正的原因。

   Some filesystems, like EXT4 I think, and very recent XFS (with the new metadata version), keep type info in the directory, so it can be returned without having to load the inode from disk. This is a huge speedup for find -name: it doesn't have to stat anything to recurse through subdirs. But for filesystems that don't do this, d_type will always be DT_UNKNOWN, because filling it in would require reading all the inodes (which might not even be loaded from disk).

3. 在进一步的原因实际上是标准的问题，就是说POSIX压根儿没有规定，一下是我摘录的大侠的论断，也许是因为directory是一个特殊的文件它存储什么内容完全是实现者的选择，的确，文件系统需要关心每个文件的内容如何吗？你需要怎样组织你的磁盘inode的分配是你的细节，你的文件存储的内容包含什么也是一个选择。

   The lowest-level portable way (portable to POSIX systems), is to use the libc functions to open a directory and read the entries. POSIX doesn't specify the exact system call interface, unlike for non-directory files.

bool doGetAllFiles(const string& strPath, vector<string>& vect)
{
    DIR *dir;
    if ((dir = opendir(strPath.c_str())) != NULL)
    {
        struct dirent *ent;
        while ((ent = readdir(dir)) != NULL)
        {
            string str = strPath+"/" +ent->d_name;
            bool bFile = false;
            bool bDirectory = false;
            struct stat st;
            if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0)
            {
                continue;
            }
            switch (ent->d_type)
            {
            case DT_DIR:
                bDirectory = true;
                break;
            case DT_REG:
                bFile = true;
                break;
            case DT_UNKNOWN:
                if (stat(str.c_str(), &st) < 0)
                {
                    return false;
                }
                if (S_ISREG(st.st_mode))
                {
                    bFile = true;
                }
                else
                {
                    if (S_ISDIR(st.st_mode))
                    {
                        bDirectory = true;
                    }
                }
                break;
            default:
                break;
            }
            if (bFile && isHtml(ent->d_name))
            {
                vect.push_back(str);
            }
            if (bDirectory && !isForbidden(ent->d_name))
            {
                if (!doGetAllFiles(str, vect))
                {
                    return false;
                }
            }
        }
        closedir(dir);
    }
    else
    {
        perror (strPath.c_str());
        return false;
    }
    return true;
}

diff --git a/src/utils.c b/src/utils.c
index 4354668..4e48592 100644
--- a/src/utils.c
+++ b/src/utils.c
@@ -623,20 +623,42 @@ file_size (const char *filename)
 /* stat file names named PREFIX.1, PREFIX.2, etc., until one that
    doesn't exist is found.  Return a freshly allocated copy of the
    unused file name.  */
-
+#define MAX_EXTENSION_LENGTH 8
 static char *
 unique_name_1 (const char *prefix)
 {
   int count = 1;
   int plen = strlen (prefix);
   char *template = (char *)alloca (plen + 1 + 24);
+  char extention_name[MAX_EXTENSION_LENGTH] = {0};
   char *template_tail = template + plen;
 
   memcpy (template, prefix, plen);
-  *template_tail++ = UNIQ_SEP;
+
+  while (template_tail != template && *template_tail != UNIQ_SEP)
+  {
+      template_tail--;
+  }
+  int size = template + plen - template_tail;
+  if (*template_tail == UNIQ_SEP && size < MAX_EXTENSION_LENGTH)
+  {
+      memcpy(extention_name, template_tail, size);
+  }
+  else
+  {
+      template_tail = template + plen;
+  }
+
+  if (*template_tail != UNIQ_SEP)
+  {
+      *template_tail++ = UNIQ_SEP;
+  }
 
   do
-    number_to_string (template_tail, count++);
+  {
+      number_to_string (template_tail, count++);
+      strcat(template_tail, extention_name);
+  }
   while (file_exists_p (template));
 
   return xstrdup (template);

#define MAX_EXTENSION_LENGTH 8
static char *
unique_name_1 (const char *prefix)
{
  int count = 1;
  int plen = strlen (prefix);
  char *template = (char *)alloca (plen + 1 + 24);
  char extention_name[MAX_EXTENSION_LENGTH] = {0};
  char *template_tail = template + plen;

  memcpy (template, prefix, plen);

  while (template_tail != template && *template_tail != UNIQ_SEP)
  {
      template_tail--;
  }
  int size = template + plen - template_tail;
  if (*template_tail == UNIQ_SEP && size < MAX_EXTENSION_LENGTH)
  {
      memcpy(extention_name, template_tail, size);
  }
  else
  {
      template_tail = template + plen;
  }

  if (*template_tail != UNIQ_SEP)
  {
      *template_tail++ = UNIQ_SEP;
  }

  do
  {
      number_to_string (template_tail, count++);
      strcat(template_tail, extention_name);
  }
  while (file_exists_p (template));

  return xstrdup (template);
}

/*
 ============================================================================
 Name        : ipmiToolTest.c
 Author      : nick
 Version     :
 Copyright   : Your copyright notice
 Description : Hello World in C, Ansi-style
 ============================================================================
 */

#include <stdio.h>
#include <stdlib.h>
#include "ipmitool/ipmi_intf.h"
#include "ipmitool/log.h"

int verbose = 0;
int csv_output = 0;

int main(void)
{
	static struct ipmi_intf * ipmi_main_intf = NULL;

	int privlvl = IPMI_SESSION_PRIV_ADMIN;

	int retry = 1;
	uint32_t timeout = 15;
	int authtype = IPMI_SESSION_AUTHTYPE_MD5;

	char * hostname = "192.168.1.135";
	char * username = "admin";
	char * password = "admin";
	char * intfname = "lan";
	char * progname = NULL;
	char * oemtype  = NULL;

	int cipher_suite_id = 4; /* See table 22-19 of the IPMIv2 spec */



	/* load interface */
	ipmi_main_intf = ipmi_intf_load(intfname);
	if (ipmi_main_intf == NULL) {
		lprintf(LOG_ERR, "Error loading interface %s", intfname);
		goto out_free;
	}

	/* setup log */
	log_init(progname, 0, verbose);

	/* run OEM setup if found */
	if (oemtype != NULL &&
	    ipmi_oem_setup(ipmi_main_intf, oemtype) < 0) {
		lprintf(LOG_ERR, "OEM setup for \"%s\" failed", oemtype);
		goto out_free;
	}

	/* set session variables */
	if (hostname != NULL)
		ipmi_intf_session_set_hostname(ipmi_main_intf, hostname);
	if (username != NULL)
		ipmi_intf_session_set_username(ipmi_main_intf, username);
	if (password != NULL)
		ipmi_intf_session_set_password(ipmi_main_intf, password);


	if (authtype >= 0)
		ipmi_intf_session_set_authtype(ipmi_main_intf, (uint8_t)authtype);
	if (privlvl > 0)
		ipmi_intf_session_set_privlvl(ipmi_main_intf, (uint8_t)privlvl);
	else
		ipmi_intf_session_set_privlvl(ipmi_main_intf,
				IPMI_SESSION_PRIV_ADMIN);	/* default */
	/* Adding retry and timeout for interface that support it */
	if (retry > 0)
		ipmi_intf_session_set_retry(ipmi_main_intf, retry);
	if (timeout > 0)
		ipmi_intf_session_set_timeout(ipmi_main_intf, timeout);

	ipmi_intf_session_set_cipher_suite_id(ipmi_main_intf, cipher_suite_id);


	struct ipmi_rs * rsp;
	struct ipmi_rq req;

	uint8_t data[256];


	memset(data, 0, sizeof(data));
	memset(&req, 0, sizeof(req));
	req.msg.netfn = IPMI_NETFN_APP;
	req.msg.lun = 0;
	req.msg.cmd = 0x01;
	req.msg.data = data;

	rsp = ipmi_main_intf->sendrecv(ipmi_main_intf, &req);

	if (rsp == NULL) {
		lprintf(LOG_ERR, "Unable to send RAW command "
			"(channel=0x%x netfn=0x%x lun=0x%x cmd=0x%x)",
			ipmi_main_intf->target_channel & 0x0f, req.msg.netfn, req.msg.lun, req.msg.cmd);
		goto out_free;
	}
	if (rsp->ccode > 0) {
		lprintf(LOG_ERR, "Unable to send RAW command "
			"(channel=0x%x netfn=0x%x lun=0x%x cmd=0x%x rsp=0x%x): %s",
			ipmi_main_intf->target_channel & 0x0f, req.msg.netfn, req.msg.lun, req.msg.cmd, rsp->ccode,
			val2str(rsp->ccode, completion_code_vals));
		goto out_free;
	}

	lprintf(LOG_INFO, "RAW RSP (%d bytes)", rsp->data_len);

	/* print the raw response buffer */
	int i = 0;
	for (i=0; i<rsp->data_len; i++) {
		if (((i%16) == 0) && (i != 0))
			printf("\n");
		printf(" %2.2x", rsp->data[i]);
	}
	printf("\n");

	out_free:
	/* clean repository caches */
	ipmi_cleanup(ipmi_main_intf);

	/* call interface close function if available */
	if (ipmi_main_intf->opened > 0 && ipmi_main_intf->close != NULL)
		ipmi_main_intf->close(ipmi_main_intf);

	log_halt();
	return 0;
}

(this->*callback)(*this, userData);

// Author      : nick
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstdio>
using namespace std;

class Human;
typedef void (Human::*CollectCallbackType)(const Human& man, void* userData);
class Human
{
public:
    Human():MaxNameLength(6)
    {
    }
    void generate()
    {
        m_nAge = rand()%30 + 20;
        char buffer[32];
        for (size_t i = 0; i < MaxNameLength; i ++)
        {
            buffer[i] = rand()%26 +'a';
        }
        buffer[MaxNameLength] = '\0';
        m_strName = buffer;
    }
    operator int() const
    {
        return m_nAge;
    }
    operator string() const
    {
        return m_strName;
    }
    void collectAgeCallback(const Human& man, void* userData)
    {
        vector<int>* pVect = (vector<int>*) userData;
        pVect->push_back((int)man);
    }
    void collectNameCallback(const Human& man, void* userData)
    {
        vector<string>* pVect = (vector<string>*)userData;
        pVect->push_back((string)man);
    }
    void collectHelper(CollectCallbackType callback, void* userData)
    {
        generate();
        (this->*callback)(*this, userData);
    }
    void collectAge(vector<int>& vectAge)
    {
        collectHelper(&Human::collectAgeCallback, &vectAge);
    }

    void collectName(vector<string>& vectName)
    {
        collectHelper(&Human::collectNameCallback, &vectName);
    }

protected:
    const size_t MaxNameLength;
    int m_nAge;
    string m_strName;
};

int main()
{
    Human man;
    vector<int> ageVect;
    vector<string> nameVect;

    for (int i = 0; i < 15; i ++)
    {
        man.collectAge(ageVect);
        man.collectName(nameVect);
    }
    for (size_t i = 0; i < ageVect.size() && i < nameVect.size(); i ++)
    {
        cout << "name:" << nameVect[i]
             << "age:" << ageVect[i] << endl;
    }
	return 0;
}

menuentry "CentOS 7.5 Live GNome ISO" {
	insmod ext2
	insmod squash4
	insmod iso9660
	insmod multiboot2
	insmod gzio
	insmod xzio
	insmod loopback
	set isofile="/media/CentOS-7-x86_64-LiveGNOME-1804.iso"
	set isolabel="CentOS-7-x86_64-LiveGNOME-1804"
	search --no-floppy --fs-uuid --set aba502d4-8460-48fb-b9d3-201256d5c410
	loopback loop (hd0,5)${isofile}
	linux (loop)/isolinux/vmlinuz0 root=live:CDLABEL=${isolabel} rootfstype=auto ro rd.live.image quiet rhgb rd.luks=0 rd.md=0 rd.dm=0 iso-scan/filename=${isofile}
	initrd (loop)/isolinux/initrd0.img 
}
menuentry "Debian 9.5 live gnome ISO" {
	insmod ext2
	insmod iso9660
	insmod loopback
	set isofile="/media/debian-live-9.5.0-amd64-gnome.iso"
	set isolabel="d-live 9.5.0 gn amd64"
	search --no-floppy --fs-uuid --set 3e00216e-8aa8-4080-a622-3f98ae5921d0
	loopback loop (hd0,5)$isofile
	linux (loop)/live/vmlinuz-4.9.0-7-amd64 boot=live components "findiso=${isofile}"
	initrd (loop)/live/initrd.img-4.9.0-7-amd64
}

menuentry "Archlinux 2018 LiveCD ISO" {
	set isofile="/media/archlinux-2018.08.01-x86_64.iso"
	search --no-floppy --fs-uuid --set aba502d4-8460-48fb-b9d3-201256d5c410
	set imgdevpath="/dev/disk/by-uuid/aba502d4-8460-48fb-b9d3-201256d5c410"
	loopback loop (hd0,5)$isofile
	linux (loop)/arch/boot/x86_64/vmlinuz img_dev=$imgdevpath img_loop=$isofile
	initrd (loop)/arch/boot/x86_64/archiso.img
}

#include <string>
#include <iostream>
#include <boost/regex.hpp>

using namespace std;

int main(int argc, char** argv)
{
	if (argc != 2)
	{
		cout << "usage: " << argv[0] << " <filename>" << endl;
		return -1;
	}
	FILE* stream = fopen(argv[1], "r");
	if (stream != NULL)
	{
		string strFormat;
		string strPreviousPartialMatch;
		boost::regex e("<[^>]*>");
		while (!feof(stream))
		{
#define BUFFER_SIZE 255
			char buffer[BUFFER_SIZE+1];
			size_t size = fread(buffer, 1, BUFFER_SIZE, stream);
			if (size > 0)
			{
				buffer[size] = '\0';
				boost::match_results<std::string::const_iterator> what;
				string str = strPreviousPartialMatch + buffer;

				strPreviousPartialMatch.clear();
				string::const_iterator start = str.begin();
				string::const_iterator end = str.end();

				while (boost::regex_search(start, end, what, e, boost::match_default | boost::match_partial))
				{
					strFormat += string(start, what[0].first);
					start = what[0].second;
					if (what[0].second == end)
					{
						strPreviousPartialMatch = string(what[0].first, end);
					}

				}
				if (start != end)
				{
					strFormat += string(start, end);
				}
			}
		}
		fclose(stream);
		cout << strFormat;
	}
	return 0;
}

#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <boost/foreach.hpp>
#include <boost/filesystem/path.hpp>
#include <boost/filesystem.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/date_time.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <string>
#include <set>
#include <exception>
#include <iterator>
#include <iostream>
#include <vector>


using namespace std;
using namespace boost;
using namespace boost::property_tree;
using namespace boost::filesystem;
using namespace boost::posix_time;

void getFile(const string& strFileName, ptree& pt)
{
	filesystem::path p(strFileName);
    if (!filesystem::exists(p))
    {
    	return;
    }

    if (!filesystem::is_directory(p))
    {
    	return;
    }
    ptree subTree;
    filesystem::directory_iterator dir = filesystem::directory_iterator(p);
    for (filesystem::directory_iterator it = dir; it != filesystem::directory_iterator(); it ++)
    {
    	if (filesystem::is_directory(it->status()))
    	{
    		getFile(it->path().string(), pt);
    	}
    	else
    	{
    		ptree filenode;
    		if (filesystem::is_regular_file(it->status()))
    		{

    			//make_pair(it->path().filename().string()
    			filenode.push_back(make_pair("file_size", lexical_cast<std::string>(filesystem::file_size(it->path()))));
    			filenode.push_back(make_pair("hard_link_count", lexical_cast<std::string>(filesystem::hard_link_count(it->path()))));
    			ptime now = from_time_t(filesystem::last_write_time(it->path()));
    			//cout << now << endl;
    			filenode.push_back(make_pair("last_write_time", lexical_cast<std::string>(now)));

    			subTree.put_child(ptree::path_type(it->path().filename().string(), '/'), filenode);

    		}
    		else
    		{
    			if (filesystem::is_symlink(it->status()))
    			{
    				filenode.push_back(make_pair("read_symlink", filesystem::read_symlink(it->path()).string()));
    				subTree.put_child(ptree::path_type(it->path().filename().string(), '/'), filenode);
    			}
    			else
    			{
    				if (filesystem::is_other(it->status()))
					{
						// ???
					}
    			}
    		}
    	}
    }

	property_tree::path treePath(p.string(), '/');
	pt.add_child(treePath, subTree);
}

void traverseTree(const ptree& pt, int indent = 0);


void traverseTree(const ptree& pt, int indent)
{
	if (pt.empty())
	{
		cout << "\"" << pt.get_value<string>() << "\"" << endl;
	}
	else
	{

		cout << "{" << endl;
		for (ptree::const_iterator it = pt.begin(); it != pt.end(); it ++)
		{
			const ptree& sub = it->second;
			cout << string(indent+4, ' ');
			cout << "\"" << it->first << "\":";

			traverseTree(sub, indent+4);
		}
		cout << string(indent, ' ');
		cout << "}" << endl;
	}
}