Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/java.security.jgss/windows/native/libsspi_bridge/sspi.cpp
branchJDK-8199569-branch
changeset 56638 052b9d3f5366
parent 56632 463c63f3497f
equal deleted inserted replaced
56632:463c63f3497f 56638:052b9d3f5366 
    29 #include <windows.h>
 
    29 #include <windows.h>
 
    30 #include <stdlib.h>
 
    30 #include <stdlib.h>
 
    31 #include <stdio.h>
 
    31 #include <stdio.h>
 
    32 #include <stdlib.h>
 
    32 #include <stdlib.h>
 
    33 #include <string.h>
 
    33 #include <string.h>
 
       
    34 #include <Strsafe.h>
 
    34 
    35 
    35 #define GSS_DLL_FILE
 
    36 #define GSS_DLL_FILE
 
    36 #include "gssapi.h"
 
    37 #include <gssapi.h>
 
    37 
    38 
    38 #define SECURITY_WIN32
 
    39 #define SECURITY_WIN32
 
    39 #include "sspi.h"
 
    40 #include <sspi.h>
 
    40 
    41 
    41 #pragma comment(lib, "secur32.lib")
 
    42 #pragma comment(lib, "secur32.lib")
 
    42 
    43 
    43 #define DEBUG
 
    44 #define DEBUG
 
    44 
    45 
   150         delete out;
 
   151         delete out;
 
   151         return NULL;
 
   152         return NULL;
 
   152     }
 
   153     }
 
   153     out->phCred = NULL;
 
   154     out->phCred = NULL;
 
   154     out->cbMaxMessage = pkgInfo->cbMaxToken;
 
   155     out->cbMaxMessage = pkgInfo->cbMaxToken;
 
   155     wcscpy(out->PackageName, PackageName);
 
   156     wcscpy_s(out->PackageName, 20, PackageName);
 
   156     FreeContextBuffer(pkgInfo);
 
   157     FreeContextBuffer(pkgInfo);
 
   157     return out;
 
   158     return out;
 
   158 }
 
   159 }
 
   159 
   160 
   160 int
 
   161 int
 
   285                 break;
 
   286                 break;
 
   286             }
 
   287             }
 
   287         }
 
   288         }
 
   288     }
 
   289     }
 
   289     name->name = value;
 
   290     name->name = value;
 
   290     lstrcpy(name->PackageName, isNegotiate ? L"Negotiate" : L"Kerberos"); // TODO
 
   291     wcscpy_s(name->PackageName, 20, isNegotiate ? L"Negotiate" : L"Kerberos"); // TODO
 
   291     *output_name = (gss_name_t) name;
 
   292     *output_name = (gss_name_t) name;
 
   292     return GSS_S_COMPLETE;
 
   293     return GSS_S_COMPLETE;
 
   293 err:
 
   294 err:
 
   294     if (value != NULL) {
 
   295     if (value != NULL) {
 
   295         delete[] value;
 
   296         delete[] value;
 
   336     names2->name = new SEC_WCHAR[lstrlen(names1->name) + 1];
 
   337     names2->name = new SEC_WCHAR[lstrlen(names1->name) + 1];
 
   337     if (names2->name == NULL) {
 
   338     if (names2->name == NULL) {
 
   338         delete names2;
 
   339         delete names2;
 
   339         return GSS_S_FAILURE;
 
   340         return GSS_S_FAILURE;
 
   340     }
 
   341     }
 
   341     wcscpy(names2->PackageName, isNegotiateOID(mech_type)
 
   342     wcscpy_s(names2->PackageName, 20, isNegotiateOID(mech_type)
 
   342             ? L"Negotiate" : L"Kerberos");
 
   343             ? L"Negotiate" : L"Kerberos");
 
   343     lstrcpy(names2->name, names1->name);
 
   344     StringCchCopy(names2->name, lstrlen(names1->name) + 1, names1->name);
 
   344     *output_name = (gss_name_t)names2;
 
   345     *output_name = (gss_name_t)names2;
 
   345     return GSS_S_COMPLETE;
 
   346     return GSS_S_COMPLETE;
 
   346 }
 
   347 }
 
   347 
   348 
   348 __declspec(dllexport) OM_uint32
 
   349 __declspec(dllexport) OM_uint32
 
   367         buffer[1] = 1;
 
   368         buffer[1] = 1;
 
   368         buffer[2] = 0;
 
   369         buffer[2] = 0;
 
   369         buffer[3] = 2 + mechLen;
 
   370         buffer[3] = 2 + mechLen;
 
   370         buffer[4] = 6;
 
   371         buffer[4] = 6;
 
   371         buffer[5] = mechLen;
 
   372         buffer[5] = mechLen;
 
   372         memcpy(buffer + 6, mech == 'K' ? KRB5_OID.elements : SPNEGO_OID.elements, 9);
 
   373         memcpy_s(buffer + 6, mechLen, mech == 'K' ? KRB5_OID.elements : SPNEGO_OID.elements, mechLen);
 
   373         buffer[6 + mechLen] = buffer[7 + mechLen] = buffer[8 + mechLen] = 0;
 
   374         buffer[6 + mechLen] = buffer[7 + mechLen] = buffer[8 + mechLen] = 0;
 
   374         buffer[9 + mechLen] = (char)len;
 
   375         buffer[9 + mechLen] = (char)len;
 
   375         if (WideCharToMultiByte(CP_ACP, 0, names, len,
 
   376         if (WideCharToMultiByte(CP_ACP, 0, names, len,
 
   376                     buffer+10+mechLen, len, NULL, NULL) == 0) {
 
   377                     buffer+10+mechLen, len, NULL, NULL) == 0) {
 
   377             delete buffer;
 
   378             delete buffer;
 
   430     cred->count = (int)desired_mech->count;
 
   431     cred->count = (int)desired_mech->count;
 
   431     cred->creds = new OneCred[cred->count];
 
   432     cred->creds = new OneCred[cred->count];
 
   432     for (int i = 0; i < cred->count; i++) {
 
   433     for (int i = 0; i < cred->count; i++) {
 
   433         TCHAR* name = isKerberosOID(&desired_mech->elements[i])
 
   434         TCHAR* name = isKerberosOID(&desired_mech->elements[i])
 
   434                 ? L"Kerberos" : L"Negotiate";
 
   435                 ? L"Kerberos" : L"Negotiate";
 
   435         wcscpy(cred->creds[i].PackageName, name);
 
   436         wcscpy_s(cred->creds[i].PackageName, 20, name);
 
   436         cred->creds[i].phCred = new CredHandle();
 
   437         cred->creds[i].phCred = new CredHandle();
 
   437         ts.QuadPart = 0;
 
   438         ts.QuadPart = 0;
 
   438         ss = AcquireCredentialsHandle(
 
   439         ss = AcquireCredentialsHandle(
 
   439                 NULL,
 
   440                 NULL,
 
   440                 name,
 
   441                 name,
 
   506         }
 
   507         }
 
   507         SEC_WCHAR* names = new SEC_WCHAR[lstrlen(snames.sUserName) + 1];
 
   508         SEC_WCHAR* names = new SEC_WCHAR[lstrlen(snames.sUserName) + 1];
 
   508         if (names == NULL) {
 
   509         if (names == NULL) {
 
   509             return GSS_S_FAILURE;
 
   510             return GSS_S_FAILURE;
 
   510         }
 
   511         }
 
   511         lstrcpy(names, snames.sUserName);
 
   512         StringCchCopy(names, lstrlen(snames.sUserName) + 1, snames.sUserName);
 
   512         FreeContextBuffer(&snames);
 
   513         FreeContextBuffer(&snames);
 
   513         PP("new name at %p", names);
 
   514         PP("new name at %p", names);
 
   514         Name* name1 = new Name;
 
   515         Name* name1 = new Name;
 
   515         if (name1 == NULL) {
 
   516         if (name1 == NULL) {
 
   516             delete[] names;
 
   517             delete[] names;
 
   517             return GSS_S_FAILURE;
 
   518             return GSS_S_FAILURE;
 
   518         }
 
   519         }
 
   519         name1->name = names;
 
   520         name1->name = names;
 
   520         lstrcpy(name1->PackageName, ((Credential*)cred_handle)->creds[0].PackageName);
 
   521         wcscpy_s(name1->PackageName, 20, ((Credential*)cred_handle)->creds[0].PackageName);
 
   521         *name = (gss_name_t) name1;
 
   522         *name = (gss_name_t) name1;
 
   522     }
 
   523     }
 
   523     if (lifetime) {
 
   524     if (lifetime) {
 
   524         *lifetime = ((Credential*)cred_handle)->time;
 
   525         *lifetime = ((Credential*)cred_handle)->time;
 
   525     }
 
   526     }
 
   677 
   678 
   678     output_token->length =  OutSecBuff.cbBuffer;
 
   679     output_token->length =  OutSecBuff.cbBuffer;
 
   679 
   680 
   680     pfDone = !((SEC_I_CONTINUE_NEEDED == ss) ||
 
   681     pfDone = !((SEC_I_CONTINUE_NEEDED == ss) ||
 
   681                 (SEC_I_COMPLETE_AND_CONTINUE == ss));
 
   682                 (SEC_I_COMPLETE_AND_CONTINUE == ss));
 
   682 
       
   683     outFlag = flagSspi2Gss(outFlag);
 
   683     outFlag = flagSspi2Gss(outFlag);
 
       
   684     PP("Done? %d outFlag: %d", pfDone, outFlag);
 
   684 
   685 
   685     *ret_flags = (OM_uint32)outFlag;
 
   686     *ret_flags = (OM_uint32)outFlag;
 
   686     if (ss == SEC_I_CONTINUE_NEEDED) {
 
   687     if (ss == SEC_I_CONTINUE_NEEDED) {
 
   687         return GSS_S_CONTINUE_NEEDED;
 
   688         return GSS_S_CONTINUE_NEEDED;
 
   688     } else {
 
   689     } else {
 
   744         n1->name = new SEC_WCHAR[lstrlen(pc->nnames.sClientName) + 1];
 
   745         n1->name = new SEC_WCHAR[lstrlen(pc->nnames.sClientName) + 1];
 
   745         if (n1->name == NULL) {
 
   746         if (n1->name == NULL) {
 
   746             goto err;
 
   747             goto err;
 
   747         }
 
   748         }
 
   748         PP("new name at %p", n1->name);
 
   749         PP("new name at %p", n1->name);
 
   749         lstrcpy(n1->name, pc->nnames.sClientName);
 
   750         StringCchCopy(n1->name, lstrlen(pc->nnames.sClientName) + 1, pc->nnames.sClientName);
 
   750         lstrcpy(n1->PackageName, pc->PackageName);
 
   751         wcscpy_s(n1->PackageName, 20, pc->PackageName);
 
   751         *src_name = (gss_name_t) n1;
 
   752         *src_name = (gss_name_t) n1;
 
   752     }
 
   753     }
 
   753     if (targ_name != NULL) {
 
   754     if (targ_name != NULL) {
 
   754         n2 = new Name;
 
   755         n2 = new Name;
 
   755         if (n2 == NULL) {
 
   756         if (n2 == NULL) {
 
   758         n2->name = new SEC_WCHAR[lstrlen(pc->nnames.sServerName) + 1];
 
   759         n2->name = new SEC_WCHAR[lstrlen(pc->nnames.sServerName) + 1];
 
   759         if (n2->name == NULL) {
 
   760         if (n2->name == NULL) {
 
   760             goto err;
 
   761             goto err;
 
   761         }
 
   762         }
 
   762         PP("new name at %p", n2->name);
 
   763         PP("new name at %p", n2->name);
 
   763         lstrcpy(n2->name, pc->nnames.sServerName);
 
   764         StringCchCopy(n2->name, lstrlen(pc->nnames.sServerName) + 1, pc->nnames.sServerName);
 
   764         lstrcpy(n2->PackageName, pc->PackageName);
 
   765         wcscpy_s(n2->PackageName, 20, pc->PackageName);
 
   765         *targ_name = (gss_name_t) n2;
 
   766         *targ_name = (gss_name_t) n2;
 
   766     }
 
   767     }
 
   767     if (lifetime_rec != NULL) {
 
   768     if (lifetime_rec != NULL) {
 
   768         SecPkgContext_Lifespan ls;
 
   769         SecPkgContext_Lifespan ls;
 
   769         SECURITY_STATUS ss;
 
   770         SECURITY_STATUS ss;
 
   964                     + pc->SecPkgContextSizes.cbBlockSize);;
 
   965                     + pc->SecPkgContextSizes.cbBlockSize);;
 
   965 
   966 
   966     SecBuff[1].BufferType = SECBUFFER_DATA;
 
   967     SecBuff[1].BufferType = SECBUFFER_DATA;
 
   967     SecBuff[1].cbBuffer = (ULONG)input_message_buffer->length;
 
   968     SecBuff[1].cbBuffer = (ULONG)input_message_buffer->length;
 
   968     SecBuff[1].pvBuffer = malloc(SecBuff[1].cbBuffer);
 
   969     SecBuff[1].pvBuffer = malloc(SecBuff[1].cbBuffer);
 
   969     memcpy(SecBuff[1].pvBuffer, input_message_buffer->value,
 
   970     memcpy_s(SecBuff[1].pvBuffer, SecBuff[1].cbBuffer,
 
   970             input_message_buffer->length);
 
   971             input_message_buffer->value, input_message_buffer->length);
 
   971 
   972 
   972     SecBuff[2].BufferType = SECBUFFER_PADDING;
 
   973     SecBuff[2].BufferType = SECBUFFER_PADDING;
 
   973     SecBuff[2].cbBuffer = pc->SecPkgContextSizes.cbBlockSize;
 
   974     SecBuff[2].cbBuffer = pc->SecPkgContextSizes.cbBlockSize;
 
   974     SecBuff[2].pvBuffer = malloc(SecBuff[2].cbBuffer);
 
   975     SecBuff[2].pvBuffer = malloc(SecBuff[2].cbBuffer);
 
   975 
   976 
   982         free(SecBuff[1].pvBuffer);
 
   983         free(SecBuff[1].pvBuffer);
 
   983         free(SecBuff[2].pvBuffer);
 
   984         free(SecBuff[2].pvBuffer);
 
   984         return GSS_S_FAILURE;
 
   985         return GSS_S_FAILURE;
 
   985     }
 
   986     }
 
   986 
   987 
   987     memcpy((PBYTE)SecBuff[0].pvBuffer + SecBuff[0].cbBuffer, SecBuff[1].pvBuffer,
 
   988     memcpy_s((PBYTE)SecBuff[0].pvBuffer + SecBuff[0].cbBuffer,
 
       
   989             input_message_buffer->length + pc->SecPkgContextSizes.cbBlockSize,
 
       
   990             SecBuff[1].pvBuffer,
 
   988             SecBuff[1].cbBuffer);
 
   991             SecBuff[1].cbBuffer);
 
   989     memcpy((PBYTE)SecBuff[0].pvBuffer + SecBuff[0].cbBuffer + SecBuff[1].cbBuffer,
 
   992     memcpy_s((PBYTE)SecBuff[0].pvBuffer + SecBuff[0].cbBuffer + SecBuff[1].cbBuffer,
 
   990             SecBuff[2].pvBuffer, SecBuff[2].cbBuffer);
 
   993             pc->SecPkgContextSizes.cbBlockSize,
 
       
   994             SecBuff[2].pvBuffer,
 
       
   995             SecBuff[2].cbBuffer);
 
   991 
   996 
   992     output_message_buffer->length = SecBuff[1].cbBuffer + SecBuff[0].cbBuffer
 
   997     output_message_buffer->length = SecBuff[1].cbBuffer + SecBuff[0].cbBuffer
 
   993             + SecBuff[2].cbBuffer;
 
   998             + SecBuff[2].cbBuffer;
 
   994     free(SecBuff[1].pvBuffer);
 
   999     free(SecBuff[1].pvBuffer);
 
   995     free(SecBuff[2].pvBuffer);
 
  1000     free(SecBuff[2].pvBuffer);
 
  1019 
  1024 
  1020     SecBuff[0].BufferType = SECBUFFER_STREAM;
 
  1025     SecBuff[0].BufferType = SECBUFFER_STREAM;
 
  1021     SecBuff[0].cbBuffer = (ULONG)input_message_buffer->length;
 
  1026     SecBuff[0].cbBuffer = (ULONG)input_message_buffer->length;
 
  1022     output_message_buffer->value = SecBuff[0].pvBuffer
 
  1027     output_message_buffer->value = SecBuff[0].pvBuffer
 
  1023             = malloc(input_message_buffer->length);
 
  1028             = malloc(input_message_buffer->length);
 
  1024     memcpy(SecBuff[0].pvBuffer, input_message_buffer->value,
 
  1029     memcpy_s(SecBuff[0].pvBuffer, input_message_buffer->length,
 
  1025             input_message_buffer->length);
 
  1030             input_message_buffer->value, input_message_buffer->length);
 
  1026 
  1031 
  1027     SecBuff[1].BufferType = SECBUFFER_DATA;
 
  1032     SecBuff[1].BufferType = SECBUFFER_DATA;
 
  1028     SecBuff[1].cbBuffer = 0;
 
  1033     SecBuff[1].cbBuffer = 0;
 
  1029     SecBuff[1].pvBuffer = NULL;
 
  1034     SecBuff[1].pvBuffer = NULL;
 
  1030 
  1035 
  1122     gss_OID newcopy = new gss_OID_desc[count + 1];
 
  1127     gss_OID newcopy = new gss_OID_desc[count + 1];
 
  1123     if (newcopy == NULL) {
 
  1128     if (newcopy == NULL) {
 
  1124         return GSS_S_FAILURE;
 
  1129         return GSS_S_FAILURE;
 
  1125     }
 
  1130     }
 
  1126     if (existing) {
 
  1131     if (existing) {
 
  1127         memcpy(newcopy, existing, count * sizeof(gss_OID_desc));
 
  1132         memcpy_s(newcopy, (count + 1) * sizeof(gss_OID_desc),
 
       
  1133                 existing, count * sizeof(gss_OID_desc));
 
  1128     }
 
  1134     }
 
  1129     newcopy[count].length = member_oid->length;
 
  1135     newcopy[count].length = member_oid->length;
 
  1130     newcopy[count].elements = new char[member_oid->length];
 
  1136     newcopy[count].elements = new char[member_oid->length];
 
  1131     if (newcopy[count].elements == NULL) {
 
  1137     if (newcopy[count].elements == NULL) {
 
  1132         delete[] newcopy;
 
  1138         delete[] newcopy;
 
  1133         return GSS_S_FAILURE;
 
  1139         return GSS_S_FAILURE;
 
  1134     }
 
  1140     }
 
  1135     memcpy(newcopy[count].elements, member_oid->elements, member_oid->length);
 
  1141     memcpy_s(newcopy[count].elements, member_oid->length,
 
       
  1142             member_oid->elements, member_oid->length);
 
  1136     (*oid_set)->elements = newcopy;
 
  1143     (*oid_set)->elements = newcopy;
 
  1137     (*oid_set)->count++;
 
  1144     (*oid_set)->count++;
 
  1138     if (existing) {
 
  1145     if (existing) {
 
  1139         delete[] existing;
 
  1146         delete[] existing;
 
  1140     }
 
  1147     }
 
  1150                    OM_uint32 *message_context,
 
  1157                    OM_uint32 *message_context,
 
  1151                    gss_buffer_t status_string)
 
  1158                    gss_buffer_t status_string)
 
  1152 {
 
  1159 {
 
  1153     PP(">>>> Calling UNIMPLEMENTED gss_display_status...");
 
  1160     PP(">>>> Calling UNIMPLEMENTED gss_display_status...");
 
  1154     status_string->value = new char[7];
 
  1161     status_string->value = new char[7];
 
  1155     memcpy(status_string->value, "Nothing", 7);
 
  1162     memcpy_s(status_string->value, 7, "Nothing", 7);
 
  1156     status_string->length = 7;
 
  1163     status_string->length = 7;
 
  1157     return GSS_S_COMPLETE;
 
  1164     return GSS_S_COMPLETE;
 
  1158 }
 
  1165 }
 
  1159 
  1166 
  1160 __declspec(dllexport) OM_uint32
 
  1167 __declspec(dllexport) OM_uint32
jdk-sandbox