crypto/pkcs7/example.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <openssl/pkcs7.h>
   4 #include <openssl/asn1_mac.h>
   5
   6 int add_signed_time(PKCS7_SIGNER_INFO *si)
   7         {
   8         ASN1_UTCTIME *sign_time;
   9
  10         /* The last parameter is the amount to add/subtract from the current
  11          * time (in seconds) */
  12         sign_time=X509_gmtime_adj(NULL,0);
  13         PKCS7_add_signed_attribute(si,NID_pkcs9_signingTime,
  14                 V_ASN1_UTCTIME,(char *)sign_time);
  15         return(1);
  16         }
  17
  18 ASN1_UTCTIME *get_signed_time(PKCS7_SIGNER_INFO *si)
  19         {
  20         ASN1_TYPE *so;
  21
  22         so=PKCS7_get_signed_attribute(si,NID_pkcs9_signingTime);
  23         if (so->type == V_ASN1_UTCTIME)
  24             return so->value.utctime;
  25         return NULL;
  26         }
  27
  28 static int signed_string_nid= -1;
  29
  30 void add_signed_string(PKCS7_SIGNER_INFO *si, char *str)
  31         {
  32         ASN1_OCTET_STRING *os;
  33
  34         /* To a an object of OID 1.2.3.4.5, which is an octet string */
  35         if (signed_string_nid == -1)
  36                 signed_string_nid=
  37                         OBJ_create("1.2.3.4.5","OID_example","Our example OID");
  38         os=ASN1_OCTET_STRING_new();
  39         ASN1_OCTET_STRING_set(os,(unsigned char*)str,strlen(str));
  40         /* When we add, we do not free */
  41         PKCS7_add_signed_attribute(si,signed_string_nid,
  42                 V_ASN1_OCTET_STRING,(char *)os);
  43         }
  44
  45 int get_signed_string(PKCS7_SIGNER_INFO *si, char *buf, int len)
  46         {
  47         ASN1_TYPE *so;
  48         ASN1_OCTET_STRING *os;
  49         int i;
  50
  51         if (signed_string_nid == -1)
  52                 signed_string_nid=
  53                         OBJ_create("1.2.3.4.5","OID_example","Our example OID");
  54         /* To retrieve */
  55         so=PKCS7_get_signed_attribute(si,signed_string_nid);
  56         if (so != NULL)
  57                 {
  58                 if (so->type == V_ASN1_OCTET_STRING)
  59                         {
  60                         os=so->value.octet_string;
  61                         i=os->length;
  62                         if ((i+1) > len)
  63                                 i=len-1;
  64                         memcpy(buf,os->data,i);
  65                         return(i);
  66                         }
  67                 }
  68         return(0);
  69         }
  70
  71 static signed_seq2string_nid= -1;
  72 /* ########################################### */
  73 int add_signed_seq2string(PKCS7_SIGNER_INFO *si, char *str1, char *str2)
  74         {
  75         /* To add an object of OID 1.9.999, which is a sequence containing
  76          * 2 octet strings */
  77         unsigned char *p;
  78         ASN1_OCTET_STRING *os1,*os2;
  79         ASN1_STRING *seq;
  80         unsigned char *data;
  81         int i,total;
  82
  83         if (signed_seq2string_nid == -1)
  84                 signed_seq2string_nid=
  85                         OBJ_create("1.9.9999","OID_example","Our example OID");
  86
  87         os1=ASN1_OCTET_STRING_new();
  88         os2=ASN1_OCTET_STRING_new();
  89         ASN1_OCTET_STRING_set(os1,(unsigned char*)str1,strlen(str1));
  90         ASN1_OCTET_STRING_set(os2,(unsigned char*)str1,strlen(str1));
  91         i =i2d_ASN1_OCTET_STRING(os1,NULL);
  92         i+=i2d_ASN1_OCTET_STRING(os2,NULL);
  93         total=ASN1_object_size(1,i,V_ASN1_SEQUENCE);
  94
  95         data=malloc(total);
  96         p=data;
  97         ASN1_put_object(&p,1,i,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL);
  98         i2d_ASN1_OCTET_STRING(os1,&p);
  99         i2d_ASN1_OCTET_STRING(os2,&p);
 100
 101         seq=ASN1_STRING_new();
 102         ASN1_STRING_set(seq,data,total);
 103         free(data);
 104         ASN1_OCTET_STRING_free(os1);
 105         ASN1_OCTET_STRING_free(os2);
 106
 107         PKCS7_add_signed_attribute(si,signed_seq2string_nid,
 108                 V_ASN1_SEQUENCE,(char *)seq);
 109         return(1);
 110         }
 111
 112 /* For this case, I will malloc the return strings */
 113 int get_signed_seq2string(PKCS7_SIGNER_INFO *si, char **str1, char **str2)
 114         {
 115         ASN1_TYPE *so;
 116
 117         if (signed_seq2string_nid == -1)
 118                 signed_seq2string_nid=
 119                         OBJ_create("1.9.9999","OID_example","Our example OID");
 120         /* To retrieve */
 121         so=PKCS7_get_signed_attribute(si,signed_seq2string_nid);
 122         if (so && (so->type == V_ASN1_SEQUENCE))
 123                 {
 124                 ASN1_CTX c;
 125                 ASN1_STRING *s;
 126                 long length;
 127                 ASN1_OCTET_STRING *os1,*os2;
 128
 129                 s=so->value.sequence;
 130                 c.p=ASN1_STRING_data(s);
 131                 c.max=c.p+ASN1_STRING_length(s);
 132                 if (!asn1_GetSequence(&c,&length)) goto err;
 133                 /* Length is the length of the seqence */
 134
 135                 c.q=c.p;
 136                 if ((os1=d2i_ASN1_OCTET_STRING(NULL,&c.p,c.slen)) == NULL)
 137                         goto err;
 138                 c.slen-=(c.p-c.q);
 139
 140                 c.q=c.p;
 141                 if ((os2=d2i_ASN1_OCTET_STRING(NULL,&c.p,c.slen)) == NULL)
 142                         goto err;
 143                 c.slen-=(c.p-c.q);
 144
 145                 if (!asn1_Finish(&c)) goto err;
 146                 *str1=malloc(os1->length+1);
 147                 *str2=malloc(os2->length+1);
 148                 memcpy(*str1,os1->data,os1->length);
 149                 memcpy(*str2,os2->data,os2->length);
 150                 (*str1)[os1->length]='\0';
 151                 (*str2)[os2->length]='\0';
 152                 ASN1_OCTET_STRING_free(os1);
 153                 ASN1_OCTET_STRING_free(os2);
 154                 return(1);
 155                 }
 156 err:
 157         return(0);
 158         }
 159
 160
 161 /* #######################################
 162  * THE OTHER WAY TO DO THINGS
 163  * #######################################
 164  */
 165 X509_ATTRIBUTE *create_time(void)
 166         {
 167         ASN1_UTCTIME *sign_time;
 168         X509_ATTRIBUTE *ret;
 169
 170         /* The last parameter is the amount to add/subtract from the current
 171          * time (in seconds) */
 172         sign_time=X509_gmtime_adj(NULL,0);
 173         ret=X509_ATTRIBUTE_create(NID_pkcs9_signingTime,
 174                 V_ASN1_UTCTIME,(char *)sign_time);
 175         return(ret);
 176         }
 177
 178 ASN1_UTCTIME *sk_get_time(STACK_OF(X509_ATTRIBUTE) *sk)
 179         {
 180         ASN1_TYPE *so;
 181         PKCS7_SIGNER_INFO si;
 182
 183         si.auth_attr=sk;
 184         so=PKCS7_get_signed_attribute(&si,NID_pkcs9_signingTime);
 185         if (so->type == V_ASN1_UTCTIME)
 186             return so->value.utctime;
 187         return NULL;
 188         }
 189
 190 X509_ATTRIBUTE *create_string(char *str)
 191         {
 192         ASN1_OCTET_STRING *os;
 193         X509_ATTRIBUTE *ret;
 194
 195         /* To a an object of OID 1.2.3.4.5, which is an octet string */
 196         if (signed_string_nid == -1)
 197                 signed_string_nid=
 198                         OBJ_create("1.2.3.4.5","OID_example","Our example OID");
 199         os=ASN1_OCTET_STRING_new();
 200         ASN1_OCTET_STRING_set(os,(unsigned char*)str,strlen(str));
 201         /* When we add, we do not free */
 202         ret=X509_ATTRIBUTE_create(signed_string_nid,
 203                 V_ASN1_OCTET_STRING,(char *)os);
 204         return(ret);
 205         }
 206
 207 int sk_get_string(STACK_OF(X509_ATTRIBUTE) *sk, char *buf, int len)
 208         {
 209         ASN1_TYPE *so;
 210         ASN1_OCTET_STRING *os;
 211         int i;
 212         PKCS7_SIGNER_INFO si;
 213
 214         si.auth_attr=sk;
 215
 216         if (signed_string_nid == -1)
 217                 signed_string_nid=
 218                         OBJ_create("1.2.3.4.5","OID_example","Our example OID");
 219         /* To retrieve */
 220         so=PKCS7_get_signed_attribute(&si,signed_string_nid);
 221         if (so != NULL)
 222                 {
 223                 if (so->type == V_ASN1_OCTET_STRING)
 224                         {
 225                         os=so->value.octet_string;
 226                         i=os->length;
 227                         if ((i+1) > len)
 228                                 i=len-1;
 229                         memcpy(buf,os->data,i);
 230                         return(i);
 231                         }
 232                 }
 233         return(0);
 234         }
 235
 236 X509_ATTRIBUTE *add_seq2string(PKCS7_SIGNER_INFO *si, char *str1, char *str2)
 237         {
 238         /* To add an object of OID 1.9.999, which is a sequence containing
 239          * 2 octet strings */
 240         unsigned char *p;
 241         ASN1_OCTET_STRING *os1,*os2;
 242         ASN1_STRING *seq;
 243         X509_ATTRIBUTE *ret;
 244         unsigned char *data;
 245         int i,total;
 246
 247         if (signed_seq2string_nid == -1)
 248                 signed_seq2string_nid=
 249                         OBJ_create("1.9.9999","OID_example","Our example OID");
 250
 251         os1=ASN1_OCTET_STRING_new();
 252         os2=ASN1_OCTET_STRING_new();
 253         ASN1_OCTET_STRING_set(os1,(unsigned char*)str1,strlen(str1));
 254         ASN1_OCTET_STRING_set(os2,(unsigned char*)str1,strlen(str1));
 255         i =i2d_ASN1_OCTET_STRING(os1,NULL);
 256         i+=i2d_ASN1_OCTET_STRING(os2,NULL);
 257         total=ASN1_object_size(1,i,V_ASN1_SEQUENCE);
 258
 259         data=malloc(total);
 260         p=data;
 261         ASN1_put_object(&p,1,i,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL);
 262         i2d_ASN1_OCTET_STRING(os1,&p);
 263         i2d_ASN1_OCTET_STRING(os2,&p);
 264
 265         seq=ASN1_STRING_new();
 266         ASN1_STRING_set(seq,data,total);
 267         free(data);
 268         ASN1_OCTET_STRING_free(os1);
 269         ASN1_OCTET_STRING_free(os2);
 270
 271         ret=X509_ATTRIBUTE_create(signed_seq2string_nid,
 272                 V_ASN1_SEQUENCE,(char *)seq);
 273         return(ret);
 274         }
 275
 276 /* For this case, I will malloc the return strings */
 277 int sk_get_seq2string(STACK_OF(X509_ATTRIBUTE) *sk, char **str1, char **str2)
 278         {
 279         ASN1_TYPE *so;
 280         PKCS7_SIGNER_INFO si;
 281
 282         if (signed_seq2string_nid == -1)
 283                 signed_seq2string_nid=
 284                         OBJ_create("1.9.9999","OID_example","Our example OID");
 285
 286         si.auth_attr=sk;
 287         /* To retrieve */
 288         so=PKCS7_get_signed_attribute(&si,signed_seq2string_nid);
 289         if (so->type == V_ASN1_SEQUENCE)
 290                 {
 291                 ASN1_CTX c;
 292                 ASN1_STRING *s;
 293                 long length;
 294                 ASN1_OCTET_STRING *os1,*os2;
 295
 296                 s=so->value.sequence;
 297                 c.p=ASN1_STRING_data(s);
 298                 c.max=c.p+ASN1_STRING_length(s);
 299                 if (!asn1_GetSequence(&c,&length)) goto err;
 300                 /* Length is the length of the seqence */
 301
 302                 c.q=c.p;
 303                 if ((os1=d2i_ASN1_OCTET_STRING(NULL,&c.p,c.slen)) == NULL)
 304                         goto err;
 305                 c.slen-=(c.p-c.q);
 306
 307                 c.q=c.p;
 308                 if ((os2=d2i_ASN1_OCTET_STRING(NULL,&c.p,c.slen)) == NULL)
 309                         goto err;
 310                 c.slen-=(c.p-c.q);
 311
 312                 if (!asn1_Finish(&c)) goto err;
 313                 *str1=malloc(os1->length+1);
 314                 *str2=malloc(os2->length+1);
 315                 memcpy(*str1,os1->data,os1->length);
 316                 memcpy(*str2,os2->data,os2->length);
 317                 (*str1)[os1->length]='\0';
 318                 (*str2)[os2->length]='\0';
 319                 ASN1_OCTET_STRING_free(os1);
 320                 ASN1_OCTET_STRING_free(os2);
 321                 return(1);
 322                 }
 323 err:
 324         return(0);
 325         }
 326
 327