crypto/pkcs7/example.c

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