project
stringclasses 633
values | commit_id
stringlengths 7
81
| target
int64 0
1
| func
stringlengths 5
484k
| cwe
stringclasses 131
values | big_vul_idx
float64 0
189k
⌀ | idx
int64 0
522k
| hash
stringlengths 34
39
| size
float64 1
24k
⌀ | message
stringlengths 0
11.5k
⌀ | dataset
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
WindowsRestructured(void)
{
DeviceIntPtr pDev = inputInfo.devices;
while (pDev) {
if (IsMaster(pDev) || IsFloating(pDev))
CheckMotion(NULL, pDev);
pDev = pDev->next;
}
}
|
CWE-119
| 4,901 | 14,235 |
198270453253508131384030870358190919196
| null | null | null |
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
XItoCoreType(int xitype)
{
int coretype = 0;
if (xitype == DeviceMotionNotify)
coretype = MotionNotify;
else if (xitype == DeviceButtonPress)
coretype = ButtonPress;
else if (xitype == DeviceButtonRelease)
coretype = ButtonRelease;
else if (xitype == DeviceKeyPress)
coretype = KeyPress;
else if (xitype == DeviceKeyRelease)
coretype = KeyRelease;
return coretype;
}
|
CWE-119
| 4,903 | 14,236 |
89076609016118360144525761569640193395
| null | null | null |
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
XYToWindow(SpritePtr pSprite, int x, int y)
{
ScreenPtr pScreen = RootWindow(pSprite)->drawable.pScreen;
return (*pScreen->XYToWindow)(pScreen, pSprite, x, y);
}
|
CWE-119
| 4,904 | 14,237 |
53043531628856002238342040133605262735
| null | null | null |
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
XineramaConfineCursorToWindow(DeviceIntPtr pDev,
WindowPtr pWin, Bool generateEvents)
{
SpritePtr pSprite = pDev->spriteInfo->sprite;
int x, y, off_x, off_y, i;
if (!XineramaSetWindowPntrs(pDev, pWin))
return;
i = PanoramiXNumScreens - 1;
RegionCopy(&pSprite->Reg1, &pSprite->windows[i]->borderSize);
off_x = screenInfo.screens[i]->x;
off_y = screenInfo.screens[i]->y;
while (i--) {
x = off_x - screenInfo.screens[i]->x;
y = off_y - screenInfo.screens[i]->y;
if (x || y)
RegionTranslate(&pSprite->Reg1, x, y);
RegionUnion(&pSprite->Reg1, &pSprite->Reg1,
&pSprite->windows[i]->borderSize);
off_x = screenInfo.screens[i]->x;
off_y = screenInfo.screens[i]->y;
}
pSprite->hotLimits = *RegionExtents(&pSprite->Reg1);
if (RegionNumRects(&pSprite->Reg1) > 1)
pSprite->hotShape = &pSprite->Reg1;
else
pSprite->hotShape = NullRegion;
pSprite->confined = FALSE;
pSprite->confineWin =
(pWin == screenInfo.screens[0]->root) ? NullWindow : pWin;
CheckPhysLimits(pDev, pSprite->current, generateEvents, FALSE, NULL);
}
|
CWE-119
| 4,905 | 14,238 |
255503216432807425838529699000369502104
| null | null | null |
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
XineramaConstrainCursor(DeviceIntPtr pDev)
{
SpritePtr pSprite = pDev->spriteInfo->sprite;
ScreenPtr pScreen;
BoxRec newBox;
pScreen = pSprite->screen;
newBox = pSprite->physLimits;
/* Translate the constraining box to the screen
the sprite is actually on */
newBox.x1 += screenInfo.screens[0]->x - pScreen->x;
newBox.x2 += screenInfo.screens[0]->x - pScreen->x;
newBox.y1 += screenInfo.screens[0]->y - pScreen->y;
newBox.y2 += screenInfo.screens[0]->y - pScreen->y;
(*pScreen->ConstrainCursor) (pDev, pScreen, &newBox);
}
|
CWE-119
| 4,906 | 14,239 |
315456834939325998450677202066583356672
| null | null | null |
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
XineramaGetCursorScreen(DeviceIntPtr pDev)
{
if (!noPanoramiXExtension) {
return pDev->spriteInfo->sprite->screen->myNum;
}
else {
return 0;
}
}
|
CWE-119
| 4,907 | 14,240 |
323611867603870090477934423569581436479
| null | null | null |
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
XineramaPointInWindowIsVisible(WindowPtr pWin, int x, int y)
{
BoxRec box;
int i, xoff, yoff;
if (!pWin->realized)
return FALSE;
if (RegionContainsPoint(&pWin->borderClip, x, y, &box))
return TRUE;
if (!XineramaSetWindowPntrs(inputInfo.pointer, pWin))
return FALSE;
xoff = x + screenInfo.screens[0]->x;
yoff = y + screenInfo.screens[0]->y;
FOR_NSCREENS_FORWARD_SKIP(i) {
pWin = inputInfo.pointer->spriteInfo->sprite->windows[i];
x = xoff - screenInfo.screens[i]->x;
y = yoff - screenInfo.screens[i]->y;
if (RegionContainsPoint(&pWin->borderClip, x, y, &box)
&& (!wInputShape(pWin) ||
RegionContainsPoint(wInputShape(pWin),
x - pWin->drawable.x,
y - pWin->drawable.y, &box)))
return TRUE;
}
return FALSE;
}
|
CWE-119
| 4,908 | 14,241 |
132907785513446075480003198007082651849
| null | null | null |
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
XineramaSetCursorPosition(DeviceIntPtr pDev, int x, int y, Bool generateEvent)
{
ScreenPtr pScreen;
int i;
SpritePtr pSprite = pDev->spriteInfo->sprite;
/* x,y are in Screen 0 coordinates. We need to decide what Screen
to send the message too and what the coordinates relative to
that screen are. */
pScreen = pSprite->screen;
x += screenInfo.screens[0]->x;
y += screenInfo.screens[0]->y;
if (!point_on_screen(pScreen, x, y)) {
FOR_NSCREENS(i) {
if (i == pScreen->myNum)
continue;
if (point_on_screen(screenInfo.screens[i], x, y)) {
pScreen = screenInfo.screens[i];
break;
}
}
}
pSprite->screen = pScreen;
pSprite->hotPhys.x = x - screenInfo.screens[0]->x;
pSprite->hotPhys.y = y - screenInfo.screens[0]->y;
x -= pScreen->x;
y -= pScreen->y;
return (*pScreen->SetCursorPosition) (pDev, pScreen, x, y, generateEvent);
}
|
CWE-119
| 4,909 | 14,242 |
235922108645378586406302059801974974684
| null | null | null |
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
XineramaSetWindowPntrs(DeviceIntPtr pDev, WindowPtr pWin)
{
SpritePtr pSprite = pDev->spriteInfo->sprite;
if (pWin == screenInfo.screens[0]->root) {
int i;
FOR_NSCREENS(i)
pSprite->windows[i] = screenInfo.screens[i]->root;
}
else {
PanoramiXRes *win;
int rc, i;
rc = dixLookupResourceByType((void **) &win, pWin->drawable.id,
XRT_WINDOW, serverClient, DixReadAccess);
if (rc != Success)
return FALSE;
FOR_NSCREENS(i) {
rc = dixLookupWindow(pSprite->windows + i, win->info[i].id,
serverClient, DixReadAccess);
if (rc != Success) /* window is being unmapped */
return FALSE;
}
}
return TRUE;
}
|
CWE-119
| 4,910 | 14,243 |
259460388380377595925256930794828082162
| null | null | null |
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
XineramaTryClientEventsResult(ClientPtr client,
GrabPtr grab, Mask mask, Mask filter)
{
if ((client) && (client != serverClient) && (!client->clientGone) &&
((filter == CantBeFiltered) || (mask & filter))) {
if (grab && !SameClient(grab, client))
return -1;
else
return 1;
}
return 0;
}
|
CWE-119
| 4,911 | 14,244 |
52892376082155537502712570207035477987
| null | null | null |
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
XineramaWarpPointer(ClientPtr client)
{
WindowPtr dest = NULL;
int x, y, rc;
SpritePtr pSprite = PickPointer(client)->spriteInfo->sprite;
REQUEST(xWarpPointerReq);
if (stuff->dstWid != None) {
rc = dixLookupWindow(&dest, stuff->dstWid, client, DixReadAccess);
if (rc != Success)
return rc;
}
x = pSprite->hotPhys.x;
y = pSprite->hotPhys.y;
if (stuff->srcWid != None) {
int winX, winY;
XID winID = stuff->srcWid;
WindowPtr source;
rc = dixLookupWindow(&source, winID, client, DixReadAccess);
if (rc != Success)
return rc;
winX = source->drawable.x;
winY = source->drawable.y;
if (source == screenInfo.screens[0]->root) {
winX -= screenInfo.screens[0]->x;
winY -= screenInfo.screens[0]->y;
}
if (x < winX + stuff->srcX ||
y < winY + stuff->srcY ||
(stuff->srcWidth != 0 &&
winX + stuff->srcX + (int) stuff->srcWidth < x) ||
(stuff->srcHeight != 0 &&
winY + stuff->srcY + (int) stuff->srcHeight < y) ||
!XineramaPointInWindowIsVisible(source, x, y))
return Success;
}
if (dest) {
x = dest->drawable.x;
y = dest->drawable.y;
if (dest == screenInfo.screens[0]->root) {
x -= screenInfo.screens[0]->x;
y -= screenInfo.screens[0]->y;
}
}
x += stuff->dstX;
y += stuff->dstY;
if (x < pSprite->physLimits.x1)
x = pSprite->physLimits.x1;
else if (x >= pSprite->physLimits.x2)
x = pSprite->physLimits.x2 - 1;
if (y < pSprite->physLimits.y1)
y = pSprite->physLimits.y1;
else if (y >= pSprite->physLimits.y2)
y = pSprite->physLimits.y2 - 1;
if (pSprite->hotShape)
ConfineToShape(PickPointer(client), pSprite->hotShape, &x, &y);
XineramaSetCursorPosition(PickPointer(client), x, y, TRUE);
return Success;
}
|
CWE-119
| 4,912 | 14,245 |
59367925099704242910373180791832318995
| null | null | null |
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
core_get_type(const xEvent *event)
{
int type = event->u.u.type;
return ((type & EXTENSION_EVENT_BASE) || type == GenericEvent) ? 0 : type;
}
|
CWE-119
| 4,913 | 14,246 |
170721441217823798726088620427470096362
| null | null | null |
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
SProcChangeProperty(ClientPtr client)
{
REQUEST(xChangePropertyReq);
swaps(&stuff->length);
REQUEST_AT_LEAST_SIZE(xChangePropertyReq);
swapl(&stuff->window);
swapl(&stuff->property);
swapl(&stuff->type);
swapl(&stuff->nUnits);
switch (stuff->format) {
case 8:
break;
case 16:
SwapRestS(stuff);
break;
case 32:
SwapRestL(stuff);
break;
}
return ((*ProcVector[X_ChangeProperty]) (client));
}
|
CWE-119
| 4,914 | 14,247 |
333278318917752838676489865462732566664
| null | null | null |
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
SProcChangeWindowAttributes(ClientPtr client)
{
REQUEST(xChangeWindowAttributesReq);
swaps(&stuff->length);
REQUEST_AT_LEAST_SIZE(xChangeWindowAttributesReq);
swapl(&stuff->window);
swapl(&stuff->valueMask);
SwapRestL(stuff);
return ((*ProcVector[X_ChangeWindowAttributes]) (client));
}
|
CWE-119
| 4,915 | 14,248 |
284548155365272143523158252911299324421
| null | null | null |
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
SProcConfigureWindow(ClientPtr client)
{
REQUEST(xConfigureWindowReq);
swaps(&stuff->length);
REQUEST_AT_LEAST_SIZE(xConfigureWindowReq);
swapl(&stuff->window);
swaps(&stuff->mask);
SwapRestL(stuff);
return ((*ProcVector[X_ConfigureWindow]) (client));
}
|
CWE-119
| 4,916 | 14,249 |
329311770857959079857807569201825015485
| null | null | null |
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
SProcConvertSelection(ClientPtr client)
{
REQUEST(xConvertSelectionReq);
swaps(&stuff->length);
REQUEST_SIZE_MATCH(xConvertSelectionReq);
swapl(&stuff->requestor);
swapl(&stuff->selection);
swapl(&stuff->target);
swapl(&stuff->property);
swapl(&stuff->time);
return ((*ProcVector[X_ConvertSelection]) (client));
}
|
CWE-119
| 4,917 | 14,250 |
121889211377489573898363307157050105618
| null | null | null |
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
SProcCreateWindow(ClientPtr client)
{
REQUEST(xCreateWindowReq);
swaps(&stuff->length);
REQUEST_AT_LEAST_SIZE(xCreateWindowReq);
swapl(&stuff->wid);
swapl(&stuff->parent);
swaps(&stuff->x);
swaps(&stuff->y);
swaps(&stuff->width);
swaps(&stuff->height);
swaps(&stuff->borderWidth);
swaps(&stuff->class);
swapl(&stuff->visual);
swapl(&stuff->mask);
SwapRestL(stuff);
return ((*ProcVector[X_CreateWindow]) (client));
}
|
CWE-119
| 4,918 | 14,251 |
266935417769756830484384100735184572606
| null | null | null |
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
SProcDeleteProperty(ClientPtr client)
{
REQUEST(xDeletePropertyReq);
swaps(&stuff->length);
REQUEST_SIZE_MATCH(xDeletePropertyReq);
swapl(&stuff->window);
swapl(&stuff->property);
return ((*ProcVector[X_DeleteProperty]) (client));
}
|
CWE-119
| 4,919 | 14,252 |
102443841889510097940852665018086402966
| null | null | null |
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
SProcInternAtom(ClientPtr client)
{
REQUEST(xInternAtomReq);
swaps(&stuff->length);
REQUEST_AT_LEAST_SIZE(xInternAtomReq);
swaps(&stuff->nbytes);
return ((*ProcVector[X_InternAtom]) (client));
}
|
CWE-119
| 4,921 | 14,253 |
243802479741789670497840889277173330433
| null | null | null |
xserver
|
215f894965df5fb0bb45b107d84524e700d2073c
| 0 |
SProcResourceReq(ClientPtr client)
{
REQUEST(xResourceReq);
swaps(&stuff->length);
REQUEST_AT_LEAST_SIZE(xResourceReq); /* not EXACT */
swapl(&stuff->id);
return (*ProcVector[stuff->reqType]) (client);
}
|
CWE-119
| 4,923 | 14,254 |
295903804875069614316554166210167355148
| null | null | null |
xserver
|
8caed4df36b1f802b4992edcfd282cbeeec35d9d
| 0 |
SProcXSendExtensionEvent(ClientPtr client)
{
CARD32 *p;
int i;
xEvent eventT = { .u.u.type = 0 };
xEvent *eventP;
EventSwapPtr proc;
REQUEST(xSendExtensionEventReq);
swaps(&stuff->length);
REQUEST_AT_LEAST_SIZE(xSendExtensionEventReq);
swapl(&stuff->destination);
swaps(&stuff->count);
if (stuff->length !=
bytes_to_int32(sizeof(xSendExtensionEventReq)) + stuff->count +
bytes_to_int32(stuff->num_events * sizeof(xEvent)))
return BadLength;
eventP = (xEvent *) &stuff[1];
for (i = 0; i < stuff->num_events; i++, eventP++) {
proc = EventSwapVector[eventP->u.u.type & 0177];
if (proc == NotImplemented) /* no swapping proc; invalid event type? */
return BadValue;
(*proc) (eventP, &eventT);
*eventP = eventT;
}
p = (CARD32 *) (((xEvent *) &stuff[1]) + stuff->num_events);
SwapLongs(p, stuff->count);
return (ProcXSendExtensionEvent(client));
}
|
CWE-119
| 4,924 | 14,255 |
267453174895275838850374093444104660884
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
void X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx)
{
if (ctx->cleanup)
ctx->cleanup(ctx);
if (ctx->param != NULL) {
if (ctx->parent == NULL)
X509_VERIFY_PARAM_free(ctx->param);
ctx->param = NULL;
}
if (ctx->tree != NULL) {
X509_policy_tree_free(ctx->tree);
ctx->tree = NULL;
}
if (ctx->chain != NULL) {
sk_X509_pop_free(ctx->chain, X509_free);
ctx->chain = NULL;
}
CRYPTO_free_ex_data(CRYPTO_EX_INDEX_X509_STORE_CTX, ctx, &(ctx->ex_data));
memset(&ctx->ex_data, 0, sizeof(CRYPTO_EX_DATA));
}
|
CWE-254
| 4,987 | 14,257 |
295781722834701230575714642309130819184
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
void X509_STORE_CTX_free(X509_STORE_CTX *ctx)
{
if (!ctx)
return;
X509_STORE_CTX_cleanup(ctx);
OPENSSL_free(ctx);
}
|
CWE-254
| 4,988 | 14,258 |
38275177541144335398823579764516897296
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
X509_CRL *X509_STORE_CTX_get0_current_crl(X509_STORE_CTX *ctx)
{
return ctx->current_crl;
}
|
CWE-254
| 4,989 | 14,259 |
230616429965004211896655478379356475932
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
X509 *X509_STORE_CTX_get0_current_issuer(X509_STORE_CTX *ctx)
{
return ctx->current_issuer;
}
|
CWE-254
| 4,990 | 14,260 |
109846251800113202742840216863099302497
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
X509_VERIFY_PARAM *X509_STORE_CTX_get0_param(X509_STORE_CTX *ctx)
{
return ctx->param;
}
|
CWE-254
| 4,991 | 14,261 |
139041814810737057972415057044540713876
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
X509_STORE_CTX *X509_STORE_CTX_get0_parent_ctx(X509_STORE_CTX *ctx)
{
return ctx->parent;
}
|
CWE-254
| 4,992 | 14,262 |
18577259236986880653545220428282098554
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
STACK_OF(X509) *X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx)
{
int i;
X509 *x;
STACK_OF(X509) *chain;
if (!ctx->chain || !(chain = sk_X509_dup(ctx->chain)))
return NULL;
for (i = 0; i < sk_X509_num(chain); i++) {
x = sk_X509_value(chain, i);
CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);
}
return chain;
}
|
CWE-254
| 4,994 | 14,263 |
98140018522006613705581458808238210861
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
STACK_OF(X509) *X509_STORE_CTX_get_chain(X509_STORE_CTX *ctx)
{
return ctx->chain;
}
|
CWE-254
| 4,995 | 14,264 |
229486297940498826260084491550193997322
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
X509 *X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx)
{
return ctx->current_cert;
}
|
CWE-254
| 4,996 | 14,265 |
256296872001434993103876026503846763164
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
int X509_STORE_CTX_get_error(X509_STORE_CTX *ctx)
{
return ctx->error;
}
|
CWE-254
| 4,997 | 14,266 |
157499157910666025579607920575284502206
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
int X509_STORE_CTX_get_error_depth(X509_STORE_CTX *ctx)
{
return ctx->error_depth;
}
|
CWE-254
| 4,998 | 14,267 |
181460356408314160013637654389855050664
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
void *X509_STORE_CTX_get_ex_data(X509_STORE_CTX *ctx, int idx)
{
return CRYPTO_get_ex_data(&ctx->ex_data, idx);
}
|
CWE-254
| 4,999 | 14,268 |
195089890789576658665195987245436466244
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
int X509_STORE_CTX_get_ex_new_index(long argl, void *argp,
CRYPTO_EX_new *new_func,
CRYPTO_EX_dup *dup_func,
CRYPTO_EX_free *free_func)
{
/*
* This function is (usually) called only once, by
* SSL_get_ex_data_X509_STORE_CTX_idx (ssl/ssl_cert.c).
*/
return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509_STORE_CTX, argl, argp,
new_func, dup_func, free_func);
}
|
CWE-254
| 5,000 | 14,269 |
277704529284595113905656020562447112154
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
int X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509,
STACK_OF(X509) *chain)
{
int ret = 1;
ctx->ctx = store;
ctx->current_method = 0;
ctx->cert = x509;
ctx->untrusted = chain;
ctx->crls = NULL;
ctx->last_untrusted = 0;
ctx->other_ctx = NULL;
ctx->valid = 0;
ctx->chain = NULL;
ctx->error = 0;
ctx->explicit_policy = 0;
ctx->error_depth = 0;
ctx->current_cert = NULL;
ctx->current_issuer = NULL;
ctx->current_crl = NULL;
ctx->current_crl_score = 0;
ctx->current_reasons = 0;
ctx->tree = NULL;
ctx->parent = NULL;
ctx->param = X509_VERIFY_PARAM_new();
if (!ctx->param) {
X509err(X509_F_X509_STORE_CTX_INIT, ERR_R_MALLOC_FAILURE);
return 0;
}
/*
* Inherit callbacks and flags from X509_STORE if not set use defaults.
*/
if (store)
ret = X509_VERIFY_PARAM_inherit(ctx->param, store->param);
else
ctx->param->inh_flags |= X509_VP_FLAG_DEFAULT | X509_VP_FLAG_ONCE;
if (store) {
ctx->verify_cb = store->verify_cb;
ctx->cleanup = store->cleanup;
} else
ctx->cleanup = 0;
if (ret)
ret = X509_VERIFY_PARAM_inherit(ctx->param,
X509_VERIFY_PARAM_lookup("default"));
if (ret == 0) {
X509err(X509_F_X509_STORE_CTX_INIT, ERR_R_MALLOC_FAILURE);
return 0;
}
if (store && store->check_issued)
ctx->check_issued = store->check_issued;
else
ctx->check_issued = check_issued;
if (store && store->get_issuer)
ctx->get_issuer = store->get_issuer;
else
ctx->get_issuer = X509_STORE_CTX_get1_issuer;
if (store && store->verify_cb)
ctx->verify_cb = store->verify_cb;
else
ctx->verify_cb = null_callback;
if (store && store->verify)
ctx->verify = store->verify;
else
ctx->verify = internal_verify;
if (store && store->check_revocation)
ctx->check_revocation = store->check_revocation;
else
ctx->check_revocation = check_revocation;
if (store && store->get_crl)
ctx->get_crl = store->get_crl;
else
ctx->get_crl = NULL;
if (store && store->check_crl)
ctx->check_crl = store->check_crl;
else
ctx->check_crl = check_crl;
if (store && store->cert_crl)
ctx->cert_crl = store->cert_crl;
else
ctx->cert_crl = cert_crl;
if (store && store->lookup_certs)
ctx->lookup_certs = store->lookup_certs;
else
ctx->lookup_certs = X509_STORE_get1_certs;
if (store && store->lookup_crls)
ctx->lookup_crls = store->lookup_crls;
else
ctx->lookup_crls = X509_STORE_get1_crls;
ctx->check_policy = check_policy;
/*
* This memset() can't make any sense anyway, so it's removed. As
* X509_STORE_CTX_cleanup does a proper "free" on the ex_data, we put a
* corresponding "new" here and remove this bogus initialisation.
*/
/* memset(&(ctx->ex_data),0,sizeof(CRYPTO_EX_DATA)); */
if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_X509_STORE_CTX, ctx,
&(ctx->ex_data))) {
OPENSSL_free(ctx);
X509err(X509_F_X509_STORE_CTX_INIT, ERR_R_MALLOC_FAILURE);
return 0;
}
return 1;
}
|
CWE-254
| 5,002 | 14,270 |
213476171088666190551841473734299365513
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
X509_STORE_CTX *X509_STORE_CTX_new(void)
{
X509_STORE_CTX *ctx;
ctx = (X509_STORE_CTX *)OPENSSL_malloc(sizeof(X509_STORE_CTX));
if (!ctx) {
X509err(X509_F_X509_STORE_CTX_NEW, ERR_R_MALLOC_FAILURE);
return NULL;
}
memset(ctx, 0, sizeof(X509_STORE_CTX));
return ctx;
}
|
CWE-254
| 5,003 | 14,271 |
264710798311679123957847918401285534772
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
int X509_STORE_CTX_purpose_inherit(X509_STORE_CTX *ctx, int def_purpose,
int purpose, int trust)
{
int idx;
/* If purpose not set use default */
if (!purpose)
purpose = def_purpose;
/* If we have a purpose then check it is valid */
if (purpose) {
X509_PURPOSE *ptmp;
idx = X509_PURPOSE_get_by_id(purpose);
if (idx == -1) {
X509err(X509_F_X509_STORE_CTX_PURPOSE_INHERIT,
X509_R_UNKNOWN_PURPOSE_ID);
return 0;
}
ptmp = X509_PURPOSE_get0(idx);
if (ptmp->trust == X509_TRUST_DEFAULT) {
idx = X509_PURPOSE_get_by_id(def_purpose);
if (idx == -1) {
X509err(X509_F_X509_STORE_CTX_PURPOSE_INHERIT,
X509_R_UNKNOWN_PURPOSE_ID);
return 0;
}
ptmp = X509_PURPOSE_get0(idx);
}
/* If trust not set then get from purpose default */
if (!trust)
trust = ptmp->trust;
}
if (trust) {
idx = X509_TRUST_get_by_id(trust);
if (idx == -1) {
X509err(X509_F_X509_STORE_CTX_PURPOSE_INHERIT,
X509_R_UNKNOWN_TRUST_ID);
return 0;
}
}
if (purpose && !ctx->param->purpose)
ctx->param->purpose = purpose;
if (trust && !ctx->param->trust)
ctx->param->trust = trust;
return 1;
}
|
CWE-254
| 5,004 | 14,272 |
227392223791576673889471925718922994238
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
void X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param)
{
if (ctx->param)
X509_VERIFY_PARAM_free(ctx->param);
ctx->param = param;
}
|
CWE-254
| 5,006 | 14,273 |
59685883090464112447609110744452589704
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
void X509_STORE_CTX_set_cert(X509_STORE_CTX *ctx, X509 *x)
{
ctx->cert = x;
}
|
CWE-254
| 5,007 | 14,274 |
241639509438941835119972822237829293667
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
void X509_STORE_CTX_set_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
{
ctx->untrusted = sk;
}
|
CWE-254
| 5,008 | 14,275 |
95378769824607015518707378308982610741
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
int X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name)
{
const X509_VERIFY_PARAM *param;
param = X509_VERIFY_PARAM_lookup(name);
if (!param)
return 0;
return X509_VERIFY_PARAM_inherit(ctx->param, param);
}
|
CWE-254
| 5,009 | 14,276 |
236719074199601321706498824978222763890
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
void X509_STORE_CTX_set_error(X509_STORE_CTX *ctx, int err)
{
ctx->error = err;
}
|
CWE-254
| 5,011 | 14,277 |
170569000292449659123249823300658318491
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
int X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx, int idx, void *data)
{
return CRYPTO_set_ex_data(&ctx->ex_data, idx, data);
}
|
CWE-254
| 5,012 | 14,278 |
196050070068697971172920723375797073500
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
void X509_STORE_CTX_set_flags(X509_STORE_CTX *ctx, unsigned long flags)
{
X509_VERIFY_PARAM_set_flags(ctx->param, flags);
}
|
CWE-254
| 5,013 | 14,279 |
55204613595951652068126948482320067946
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
int X509_STORE_CTX_set_purpose(X509_STORE_CTX *ctx, int purpose)
{
return X509_STORE_CTX_purpose_inherit(ctx, 0, purpose, 0);
}
|
CWE-254
| 5,014 | 14,280 |
121194855238206628255517876896349200761
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
void X509_STORE_CTX_set_time(X509_STORE_CTX *ctx, unsigned long flags,
time_t t)
{
X509_VERIFY_PARAM_set_time(ctx->param, t);
}
|
CWE-254
| 5,015 | 14,281 |
235392990897471193686936220066745648374
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
int X509_STORE_CTX_set_trust(X509_STORE_CTX *ctx, int trust)
{
return X509_STORE_CTX_purpose_inherit(ctx, 0, 0, trust);
}
|
CWE-254
| 5,016 | 14,282 |
281961145279567331567581744561517693721
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
void X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx,
int (*verify_cb) (int, X509_STORE_CTX *))
{
ctx->verify_cb = verify_cb;
}
|
CWE-254
| 5,017 | 14,283 |
31697873294437488456713077453297527078
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
void X509_STORE_CTX_trusted_stack(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
{
ctx->other_ctx = sk;
ctx->get_issuer = get_issuer_sk;
}
|
CWE-254
| 5,018 | 14,284 |
31986130846623104439859562551891371496
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
int X509_cmp_current_time(const ASN1_TIME *ctm)
{
return X509_cmp_time(ctm, NULL);
}
|
CWE-254
| 5,019 | 14,285 |
211629776446133319239002293633506853410
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
int X509_cmp_time(const ASN1_TIME *ctm, time_t *cmp_time)
{
char *str;
ASN1_TIME atm;
long offset;
char buff1[24], buff2[24], *p;
int i, j, remaining;
p = buff1;
remaining = ctm->length;
str = (char *)ctm->data;
/*
* Note that the following (historical) code allows much more slack in the
* time format than RFC5280. In RFC5280, the representation is fixed:
* UTCTime: YYMMDDHHMMSSZ
* GeneralizedTime: YYYYMMDDHHMMSSZ
*/
if (ctm->type == V_ASN1_UTCTIME) {
/* YYMMDDHHMM[SS]Z or YYMMDDHHMM[SS](+-)hhmm */
int min_length = sizeof("YYMMDDHHMMZ") - 1;
int max_length = sizeof("YYMMDDHHMMSS+hhmm") - 1;
if (remaining < min_length || remaining > max_length)
return 0;
memcpy(p, str, 10);
p += 10;
str += 10;
remaining -= 10;
} else {
/* YYYYMMDDHHMM[SS[.fff]]Z or YYYYMMDDHHMM[SS[.f[f[f]]]](+-)hhmm */
int min_length = sizeof("YYYYMMDDHHMMZ") - 1;
int max_length = sizeof("YYYYMMDDHHMMSS.fff+hhmm") - 1;
if (remaining < min_length || remaining > max_length)
return 0;
memcpy(p, str, 12);
p += 12;
str += 12;
remaining -= 12;
}
if ((*str == 'Z') || (*str == '-') || (*str == '+')) {
*(p++) = '0';
*(p++) = '0';
} else {
/* SS (seconds) */
if (remaining < 2)
return 0;
*(p++) = *(str++);
*(p++) = *(str++);
remaining -= 2;
/*
* Skip any (up to three) fractional seconds...
* TODO(emilia): in RFC5280, fractional seconds are forbidden.
* Can we just kill them altogether?
*/
if (remaining && *str == '.') {
str++;
remaining--;
for (i = 0; i < 3 && remaining; i++, str++, remaining--) {
if (*str < '0' || *str > '9')
break;
}
}
}
*(p++) = 'Z';
*(p++) = '\0';
/* We now need either a terminating 'Z' or an offset. */
if (!remaining)
return 0;
if (*str == 'Z') {
if (remaining != 1)
return 0;
offset = 0;
} else {
/* (+-)HHMM */
if ((*str != '+') && (*str != '-'))
return 0;
/* Historical behaviour: the (+-)hhmm offset is forbidden in RFC5280. */
if (remaining != 5)
return 0;
if (str[1] < '0' || str[1] > '9' || str[2] < '0' || str[2] > '9' ||
str[3] < '0' || str[3] > '9' || str[4] < '0' || str[4] > '9')
return 0;
offset = ((str[1] - '0') * 10 + (str[2] - '0')) * 60;
offset += (str[3] - '0') * 10 + (str[4] - '0');
if (*str == '-')
offset = -offset;
}
atm.type = ctm->type;
atm.flags = 0;
atm.length = sizeof(buff2);
atm.data = (unsigned char *)buff2;
if (X509_time_adj(&atm, offset * 60, cmp_time) == NULL)
return 0;
if (ctm->type == V_ASN1_UTCTIME) {
i = (buff1[0] - '0') * 10 + (buff1[1] - '0');
if (i < 50)
i += 100; /* cf. RFC 2459 */
j = (buff2[0] - '0') * 10 + (buff2[1] - '0');
if (j < 50)
j += 100;
if (i < j)
return -1;
if (i > j)
return 1;
}
i = strcmp(buff1, buff2);
if (i == 0) /* wait a second then return younger :-) */
return -1;
else
return i;
}
|
CWE-254
| 5,020 | 14,286 |
42516620700749431323659321844963675197
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
int X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain)
{
EVP_PKEY *ktmp = NULL, *ktmp2;
int i, j;
if ((pkey != NULL) && !EVP_PKEY_missing_parameters(pkey))
return 1;
for (i = 0; i < sk_X509_num(chain); i++) {
ktmp = X509_get_pubkey(sk_X509_value(chain, i));
if (ktmp == NULL) {
X509err(X509_F_X509_GET_PUBKEY_PARAMETERS,
X509_R_UNABLE_TO_GET_CERTS_PUBLIC_KEY);
return 0;
}
if (!EVP_PKEY_missing_parameters(ktmp))
break;
else {
EVP_PKEY_free(ktmp);
ktmp = NULL;
}
}
if (ktmp == NULL) {
X509err(X509_F_X509_GET_PUBKEY_PARAMETERS,
X509_R_UNABLE_TO_FIND_PARAMETERS_IN_CHAIN);
return 0;
}
/* first, populate the other certs */
for (j = i - 1; j >= 0; j--) {
ktmp2 = X509_get_pubkey(sk_X509_value(chain, j));
EVP_PKEY_copy_parameters(ktmp2, ktmp);
EVP_PKEY_free(ktmp2);
}
if (pkey != NULL)
EVP_PKEY_copy_parameters(pkey, ktmp);
EVP_PKEY_free(ktmp);
return 1;
}
|
CWE-254
| 5,021 | 14,287 |
10919653726976356359716064209366453034
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
ASN1_TIME *X509_gmtime_adj(ASN1_TIME *s, long adj)
{
return X509_time_adj(s, adj, NULL);
}
|
CWE-254
| 5,022 | 14,288 |
226840130291325182042041874367707225699
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
ASN1_TIME *X509_time_adj(ASN1_TIME *s, long offset_sec, time_t *in_tm)
{
return X509_time_adj_ex(s, 0, offset_sec, in_tm);
}
|
CWE-254
| 5,023 | 14,289 |
97409617897005692614512696239999056941
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
ASN1_TIME *X509_time_adj_ex(ASN1_TIME *s,
int offset_day, long offset_sec, time_t *in_tm)
{
time_t t;
if (in_tm)
t = *in_tm;
else
time(&t);
if (s && !(s->flags & ASN1_STRING_FLAG_MSTRING)) {
if (s->type == V_ASN1_UTCTIME)
return ASN1_UTCTIME_adj(s, t, offset_day, offset_sec);
if (s->type == V_ASN1_GENERALIZEDTIME)
return ASN1_GENERALIZEDTIME_adj(s, t, offset_day, offset_sec);
}
return ASN1_TIME_adj(s, t, offset_day, offset_sec);
}
|
CWE-254
| 5,024 | 14,290 |
76509303154976231033755373064509837233
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int cert_crl(X509_STORE_CTX *ctx, X509_CRL *crl, X509 *x)
{
int ok;
X509_REVOKED *rev;
/*
* The rules changed for this... previously if a CRL contained unhandled
* critical extensions it could still be used to indicate a certificate
* was revoked. This has since been changed since critical extension can
* change the meaning of CRL entries.
*/
if (!(ctx->param->flags & X509_V_FLAG_IGNORE_CRITICAL)
&& (crl->flags & EXFLAG_CRITICAL)) {
ctx->error = X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION;
ok = ctx->verify_cb(0, ctx);
if (!ok)
return 0;
}
/*
* Look for serial number of certificate in CRL If found make sure reason
* is not removeFromCRL.
*/
if (X509_CRL_get0_by_cert(crl, &rev, x)) {
if (rev->reason == CRL_REASON_REMOVE_FROM_CRL)
return 2;
ctx->error = X509_V_ERR_CERT_REVOKED;
ok = ctx->verify_cb(0, ctx);
if (!ok)
return 0;
}
return 1;
}
|
CWE-254
| 5,025 | 14,291 |
323892405578483435459191357846423471438
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int check_cert(X509_STORE_CTX *ctx)
{
X509_CRL *crl = NULL, *dcrl = NULL;
X509 *x;
int ok, cnum;
unsigned int last_reasons;
cnum = ctx->error_depth;
x = sk_X509_value(ctx->chain, cnum);
ctx->current_cert = x;
ctx->current_issuer = NULL;
ctx->current_crl_score = 0;
ctx->current_reasons = 0;
while (ctx->current_reasons != CRLDP_ALL_REASONS) {
last_reasons = ctx->current_reasons;
/* Try to retrieve relevant CRL */
if (ctx->get_crl)
ok = ctx->get_crl(ctx, &crl, x);
else
ok = get_crl_delta(ctx, &crl, &dcrl, x);
/*
* If error looking up CRL, nothing we can do except notify callback
*/
if (!ok) {
ctx->error = X509_V_ERR_UNABLE_TO_GET_CRL;
ok = ctx->verify_cb(0, ctx);
goto err;
}
ctx->current_crl = crl;
ok = ctx->check_crl(ctx, crl);
if (!ok)
goto err;
if (dcrl) {
ok = ctx->check_crl(ctx, dcrl);
if (!ok)
goto err;
ok = ctx->cert_crl(ctx, dcrl, x);
if (!ok)
goto err;
} else
ok = 1;
/* Don't look in full CRL if delta reason is removefromCRL */
if (ok != 2) {
ok = ctx->cert_crl(ctx, crl, x);
if (!ok)
goto err;
}
X509_CRL_free(crl);
X509_CRL_free(dcrl);
crl = NULL;
dcrl = NULL;
/*
* If reasons not updated we wont get anywhere by another iteration,
* so exit loop.
*/
if (last_reasons == ctx->current_reasons) {
ctx->error = X509_V_ERR_UNABLE_TO_GET_CRL;
ok = ctx->verify_cb(0, ctx);
goto err;
}
}
err:
X509_CRL_free(crl);
X509_CRL_free(dcrl);
ctx->current_crl = NULL;
return ok;
}
|
CWE-254
| 5,026 | 14,292 |
257634959046123481290648825999464895735
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int check_cert_time(X509_STORE_CTX *ctx, X509 *x)
{
time_t *ptime;
int i;
if (ctx->param->flags & X509_V_FLAG_USE_CHECK_TIME)
ptime = &ctx->param->check_time;
else
ptime = NULL;
i = X509_cmp_time(X509_get_notBefore(x), ptime);
if (i == 0) {
ctx->error = X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD;
ctx->current_cert = x;
if (!ctx->verify_cb(0, ctx))
return 0;
}
if (i > 0) {
ctx->error = X509_V_ERR_CERT_NOT_YET_VALID;
ctx->current_cert = x;
if (!ctx->verify_cb(0, ctx))
return 0;
}
i = X509_cmp_time(X509_get_notAfter(x), ptime);
if (i == 0) {
ctx->error = X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD;
ctx->current_cert = x;
if (!ctx->verify_cb(0, ctx))
return 0;
}
if (i < 0) {
ctx->error = X509_V_ERR_CERT_HAS_EXPIRED;
ctx->current_cert = x;
if (!ctx->verify_cb(0, ctx))
return 0;
}
return 1;
}
|
CWE-254
| 5,027 | 14,293 |
133248483823695829435114297766812454431
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int check_chain_extensions(X509_STORE_CTX *ctx)
{
#ifdef OPENSSL_NO_CHAIN_VERIFY
return 1;
#else
int i, ok = 0, must_be_ca, plen = 0;
X509 *x;
int (*cb) (int xok, X509_STORE_CTX *xctx);
int proxy_path_length = 0;
int purpose;
int allow_proxy_certs;
cb = ctx->verify_cb;
/*-
* must_be_ca can have 1 of 3 values:
* -1: we accept both CA and non-CA certificates, to allow direct
* use of self-signed certificates (which are marked as CA).
* 0: we only accept non-CA certificates. This is currently not
* used, but the possibility is present for future extensions.
* 1: we only accept CA certificates. This is currently used for
* all certificates in the chain except the leaf certificate.
*/
must_be_ca = -1;
/* CRL path validation */
if (ctx->parent) {
allow_proxy_certs = 0;
purpose = X509_PURPOSE_CRL_SIGN;
} else {
allow_proxy_certs =
! !(ctx->param->flags & X509_V_FLAG_ALLOW_PROXY_CERTS);
/*
* A hack to keep people who don't want to modify their software
* happy
*/
if (getenv("OPENSSL_ALLOW_PROXY_CERTS"))
allow_proxy_certs = 1;
purpose = ctx->param->purpose;
}
/* Check all untrusted certificates */
for (i = 0; i < ctx->last_untrusted; i++) {
int ret;
x = sk_X509_value(ctx->chain, i);
if (!(ctx->param->flags & X509_V_FLAG_IGNORE_CRITICAL)
&& (x->ex_flags & EXFLAG_CRITICAL)) {
ctx->error = X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION;
ctx->error_depth = i;
ctx->current_cert = x;
ok = cb(0, ctx);
if (!ok)
goto end;
}
if (!allow_proxy_certs && (x->ex_flags & EXFLAG_PROXY)) {
ctx->error = X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED;
ctx->error_depth = i;
ctx->current_cert = x;
ok = cb(0, ctx);
if (!ok)
goto end;
}
ret = X509_check_ca(x);
switch (must_be_ca) {
case -1:
if ((ctx->param->flags & X509_V_FLAG_X509_STRICT)
&& (ret != 1) && (ret != 0)) {
ret = 0;
ctx->error = X509_V_ERR_INVALID_CA;
} else
ret = 1;
break;
case 0:
if (ret != 0) {
ret = 0;
ctx->error = X509_V_ERR_INVALID_NON_CA;
} else
ret = 1;
break;
default:
if ((ret == 0)
|| ((ctx->param->flags & X509_V_FLAG_X509_STRICT)
&& (ret != 1))) {
ret = 0;
ctx->error = X509_V_ERR_INVALID_CA;
} else
ret = 1;
break;
}
if (ret == 0) {
ctx->error_depth = i;
ctx->current_cert = x;
ok = cb(0, ctx);
if (!ok)
goto end;
}
if (ctx->param->purpose > 0) {
ret = X509_check_purpose(x, purpose, must_be_ca > 0);
if ((ret == 0)
|| ((ctx->param->flags & X509_V_FLAG_X509_STRICT)
&& (ret != 1))) {
ctx->error = X509_V_ERR_INVALID_PURPOSE;
ctx->error_depth = i;
ctx->current_cert = x;
ok = cb(0, ctx);
if (!ok)
goto end;
}
}
/* Check pathlen if not self issued */
if ((i > 1) && !(x->ex_flags & EXFLAG_SI)
&& (x->ex_pathlen != -1)
&& (plen > (x->ex_pathlen + proxy_path_length + 1))) {
ctx->error = X509_V_ERR_PATH_LENGTH_EXCEEDED;
ctx->error_depth = i;
ctx->current_cert = x;
ok = cb(0, ctx);
if (!ok)
goto end;
}
/* Increment path length if not self issued */
if (!(x->ex_flags & EXFLAG_SI))
plen++;
/*
* If this certificate is a proxy certificate, the next certificate
* must be another proxy certificate or a EE certificate. If not,
* the next certificate must be a CA certificate.
*/
if (x->ex_flags & EXFLAG_PROXY) {
if (x->ex_pcpathlen != -1 && i > x->ex_pcpathlen) {
ctx->error = X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED;
ctx->error_depth = i;
ctx->current_cert = x;
ok = cb(0, ctx);
if (!ok)
goto end;
}
proxy_path_length++;
must_be_ca = 0;
} else
must_be_ca = 1;
}
ok = 1;
end:
return ok;
#endif
}
|
CWE-254
| 5,028 | 14,294 |
154608733547769275412481143252819657984
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int check_crl(X509_STORE_CTX *ctx, X509_CRL *crl)
{
X509 *issuer = NULL;
EVP_PKEY *ikey = NULL;
int ok = 0, chnum, cnum;
cnum = ctx->error_depth;
chnum = sk_X509_num(ctx->chain) - 1;
/* if we have an alternative CRL issuer cert use that */
if (ctx->current_issuer)
issuer = ctx->current_issuer;
/*
* Else find CRL issuer: if not last certificate then issuer is next
* certificate in chain.
*/
else if (cnum < chnum)
issuer = sk_X509_value(ctx->chain, cnum + 1);
else {
issuer = sk_X509_value(ctx->chain, chnum);
/* If not self signed, can't check signature */
if (!ctx->check_issued(ctx, issuer, issuer)) {
ctx->error = X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER;
ok = ctx->verify_cb(0, ctx);
if (!ok)
goto err;
}
}
if (issuer) {
/*
* Skip most tests for deltas because they have already been done
*/
if (!crl->base_crl_number) {
/* Check for cRLSign bit if keyUsage present */
if ((issuer->ex_flags & EXFLAG_KUSAGE) &&
!(issuer->ex_kusage & KU_CRL_SIGN)) {
ctx->error = X509_V_ERR_KEYUSAGE_NO_CRL_SIGN;
ok = ctx->verify_cb(0, ctx);
if (!ok)
goto err;
}
if (!(ctx->current_crl_score & CRL_SCORE_SCOPE)) {
ctx->error = X509_V_ERR_DIFFERENT_CRL_SCOPE;
ok = ctx->verify_cb(0, ctx);
if (!ok)
goto err;
}
if (!(ctx->current_crl_score & CRL_SCORE_SAME_PATH)) {
if (check_crl_path(ctx, ctx->current_issuer) <= 0) {
ctx->error = X509_V_ERR_CRL_PATH_VALIDATION_ERROR;
ok = ctx->verify_cb(0, ctx);
if (!ok)
goto err;
}
}
if (crl->idp_flags & IDP_INVALID) {
ctx->error = X509_V_ERR_INVALID_EXTENSION;
ok = ctx->verify_cb(0, ctx);
if (!ok)
goto err;
}
}
if (!(ctx->current_crl_score & CRL_SCORE_TIME)) {
ok = check_crl_time(ctx, crl, 1);
if (!ok)
goto err;
}
/* Attempt to get issuer certificate public key */
ikey = X509_get_pubkey(issuer);
if (!ikey) {
ctx->error = X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY;
ok = ctx->verify_cb(0, ctx);
if (!ok)
goto err;
} else {
/* Verify CRL signature */
if (X509_CRL_verify(crl, ikey) <= 0) {
ctx->error = X509_V_ERR_CRL_SIGNATURE_FAILURE;
ok = ctx->verify_cb(0, ctx);
if (!ok)
goto err;
}
}
}
ok = 1;
err:
EVP_PKEY_free(ikey);
return ok;
}
|
CWE-254
| 5,029 | 14,295 |
1211479154073217376886462038824497258
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int check_crl_chain(X509_STORE_CTX *ctx,
STACK_OF(X509) *cert_path,
STACK_OF(X509) *crl_path)
{
X509 *cert_ta, *crl_ta;
cert_ta = sk_X509_value(cert_path, sk_X509_num(cert_path) - 1);
crl_ta = sk_X509_value(crl_path, sk_X509_num(crl_path) - 1);
if (!X509_cmp(cert_ta, crl_ta))
return 1;
return 0;
}
|
CWE-254
| 5,030 | 14,296 |
110094097363095318074783572041654425989
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int check_delta_base(X509_CRL *delta, X509_CRL *base)
{
/* Delta CRL must be a delta */
if (!delta->base_crl_number)
return 0;
/* Base must have a CRL number */
if (!base->crl_number)
return 0;
/* Issuer names must match */
if (X509_NAME_cmp(X509_CRL_get_issuer(base), X509_CRL_get_issuer(delta)))
return 0;
/* AKID and IDP must match */
if (!crl_extension_match(delta, base, NID_authority_key_identifier))
return 0;
if (!crl_extension_match(delta, base, NID_issuing_distribution_point))
return 0;
/* Delta CRL base number must not exceed Full CRL number. */
if (ASN1_INTEGER_cmp(delta->base_crl_number, base->crl_number) > 0)
return 0;
/* Delta CRL number must exceed full CRL number */
if (ASN1_INTEGER_cmp(delta->crl_number, base->crl_number) > 0)
return 1;
return 0;
}
|
CWE-254
| 5,033 | 14,297 |
73169687235013274125911452012989517261
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int check_issued(X509_STORE_CTX *ctx, X509 *x, X509 *issuer)
{
int ret;
ret = X509_check_issued(issuer, x);
if (ret == X509_V_OK)
return 1;
/* If we haven't asked for issuer errors don't set ctx */
if (!(ctx->param->flags & X509_V_FLAG_CB_ISSUER_CHECK))
return 0;
ctx->error = ret;
ctx->current_cert = x;
ctx->current_issuer = issuer;
return ctx->verify_cb(0, ctx);
return 0;
}
|
CWE-254
| 5,034 | 14,298 |
323536092688415411213287357407751870237
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int check_name_constraints(X509_STORE_CTX *ctx)
{
X509 *x;
int i, j, rv;
/* Check name constraints for all certificates */
for (i = sk_X509_num(ctx->chain) - 1; i >= 0; i--) {
x = sk_X509_value(ctx->chain, i);
/* Ignore self issued certs unless last in chain */
if (i && (x->ex_flags & EXFLAG_SI))
continue;
/*
* Check against constraints for all certificates higher in chain
* including trust anchor. Trust anchor not strictly speaking needed
* but if it includes constraints it is to be assumed it expects them
* to be obeyed.
*/
for (j = sk_X509_num(ctx->chain) - 1; j > i; j--) {
NAME_CONSTRAINTS *nc = sk_X509_value(ctx->chain, j)->nc;
if (nc) {
rv = NAME_CONSTRAINTS_check(x, nc);
if (rv != X509_V_OK) {
ctx->error = rv;
ctx->error_depth = i;
ctx->current_cert = x;
if (!ctx->verify_cb(0, ctx))
return 0;
}
}
}
}
return 1;
}
|
CWE-254
| 5,035 | 14,299 |
197514088683345208838390684808745054643
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int check_policy(X509_STORE_CTX *ctx)
{
int ret;
if (ctx->parent)
return 1;
ret = X509_policy_check(&ctx->tree, &ctx->explicit_policy, ctx->chain,
ctx->param->policies, ctx->param->flags);
if (ret == 0) {
X509err(X509_F_CHECK_POLICY, ERR_R_MALLOC_FAILURE);
return 0;
}
/* Invalid or inconsistent extensions */
if (ret == -1) {
/*
* Locate certificates with bad extensions and notify callback.
*/
X509 *x;
int i;
for (i = 1; i < sk_X509_num(ctx->chain); i++) {
x = sk_X509_value(ctx->chain, i);
if (!(x->ex_flags & EXFLAG_INVALID_POLICY))
continue;
ctx->current_cert = x;
ctx->error = X509_V_ERR_INVALID_POLICY_EXTENSION;
if (!ctx->verify_cb(0, ctx))
return 0;
}
return 1;
}
if (ret == -2) {
ctx->current_cert = NULL;
ctx->error = X509_V_ERR_NO_EXPLICIT_POLICY;
return ctx->verify_cb(0, ctx);
}
if (ctx->param->flags & X509_V_FLAG_NOTIFY_POLICY) {
ctx->current_cert = NULL;
ctx->error = X509_V_OK;
if (!ctx->verify_cb(2, ctx))
return 0;
}
return 1;
}
|
CWE-254
| 5,036 | 14,300 |
13587717652884840111869253014968154899
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int check_revocation(X509_STORE_CTX *ctx)
{
int i, last, ok;
if (!(ctx->param->flags & X509_V_FLAG_CRL_CHECK))
return 1;
if (ctx->param->flags & X509_V_FLAG_CRL_CHECK_ALL)
last = sk_X509_num(ctx->chain) - 1;
else {
/* If checking CRL paths this isn't the EE certificate */
if (ctx->parent)
return 1;
last = 0;
}
for (i = 0; i <= last; i++) {
ctx->error_depth = i;
ok = check_cert(ctx);
if (!ok)
return ok;
}
return 1;
}
|
CWE-254
| 5,037 | 14,301 |
24040398070464230461201356887636167892
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int check_trust(X509_STORE_CTX *ctx)
{
#ifdef OPENSSL_NO_CHAIN_VERIFY
return 1;
#else
int i, ok;
X509 *x;
int (*cb) (int xok, X509_STORE_CTX *xctx);
cb = ctx->verify_cb;
/* For now just check the last certificate in the chain */
i = sk_X509_num(ctx->chain) - 1;
x = sk_X509_value(ctx->chain, i);
ok = X509_check_trust(x, ctx->param->trust, 0);
if (ok == X509_TRUST_TRUSTED)
return 1;
ctx->error_depth = i;
ctx->current_cert = x;
if (ok == X509_TRUST_REJECTED)
ctx->error = X509_V_ERR_CERT_REJECTED;
else
ctx->error = X509_V_ERR_CERT_UNTRUSTED;
ok = cb(0, ctx);
return ok;
#endif
}
|
CWE-254
| 5,038 | 14,302 |
118015788937173590771951082242161707796
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int crl_crldp_check(X509 *x, X509_CRL *crl, int crl_score,
unsigned int *preasons)
{
int i;
if (crl->idp_flags & IDP_ONLYATTR)
return 0;
if (x->ex_flags & EXFLAG_CA) {
if (crl->idp_flags & IDP_ONLYUSER)
return 0;
} else {
if (crl->idp_flags & IDP_ONLYCA)
return 0;
}
*preasons = crl->idp_reasons;
for (i = 0; i < sk_DIST_POINT_num(x->crldp); i++) {
DIST_POINT *dp = sk_DIST_POINT_value(x->crldp, i);
if (crldp_check_crlissuer(dp, crl, crl_score)) {
if (!crl->idp || idp_check_dp(dp->distpoint, crl->idp->distpoint)) {
*preasons &= dp->dp_reasons;
return 1;
}
}
}
if ((!crl->idp || !crl->idp->distpoint)
&& (crl_score & CRL_SCORE_ISSUER_NAME))
return 1;
return 0;
}
|
CWE-254
| 5,040 | 14,303 |
58711699200072391739770987567143366475
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int crl_extension_match(X509_CRL *a, X509_CRL *b, int nid)
{
ASN1_OCTET_STRING *exta, *extb;
int i;
i = X509_CRL_get_ext_by_NID(a, nid, -1);
if (i >= 0) {
/* Can't have multiple occurrences */
if (X509_CRL_get_ext_by_NID(a, nid, i) != -1)
return 0;
exta = X509_EXTENSION_get_data(X509_CRL_get_ext(a, i));
} else
exta = NULL;
i = X509_CRL_get_ext_by_NID(b, nid, -1);
if (i >= 0) {
if (X509_CRL_get_ext_by_NID(b, nid, i) != -1)
return 0;
extb = X509_EXTENSION_get_data(X509_CRL_get_ext(b, i));
} else
extb = NULL;
if (!exta && !extb)
return 1;
if (!exta || !extb)
return 0;
if (ASN1_OCTET_STRING_cmp(exta, extb))
return 0;
return 1;
}
|
CWE-254
| 5,041 | 14,304 |
228042823625101831830905458943618206773
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int crldp_check_crlissuer(DIST_POINT *dp, X509_CRL *crl, int crl_score)
{
int i;
X509_NAME *nm = X509_CRL_get_issuer(crl);
/* If no CRLissuer return is successful iff don't need a match */
if (!dp->CRLissuer)
return ! !(crl_score & CRL_SCORE_ISSUER_NAME);
for (i = 0; i < sk_GENERAL_NAME_num(dp->CRLissuer); i++) {
GENERAL_NAME *gen = sk_GENERAL_NAME_value(dp->CRLissuer, i);
if (gen->type != GEN_DIRNAME)
continue;
if (!X509_NAME_cmp(gen->d.directoryName, nm))
return 1;
}
return 0;
}
|
CWE-254
| 5,042 | 14,305 |
187198825094575594131500472838066898988
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static X509 *find_issuer(X509_STORE_CTX *ctx, STACK_OF(X509) *sk, X509 *x)
{
int i;
X509 *issuer;
for (i = 0; i < sk_X509_num(sk); i++) {
issuer = sk_X509_value(sk, i);
if (ctx->check_issued(ctx, x, issuer))
return issuer;
}
return NULL;
}
|
CWE-254
| 5,043 | 14,306 |
264026246061203633606732246550578709278
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int get_crl_delta(X509_STORE_CTX *ctx,
X509_CRL **pcrl, X509_CRL **pdcrl, X509 *x)
{
int ok;
X509 *issuer = NULL;
int crl_score = 0;
unsigned int reasons;
X509_CRL *crl = NULL, *dcrl = NULL;
STACK_OF(X509_CRL) *skcrl;
X509_NAME *nm = X509_get_issuer_name(x);
reasons = ctx->current_reasons;
ok = get_crl_sk(ctx, &crl, &dcrl,
&issuer, &crl_score, &reasons, ctx->crls);
if (ok)
goto done;
/* Lookup CRLs from store */
skcrl = ctx->lookup_crls(ctx, nm);
/* If no CRLs found and a near match from get_crl_sk use that */
if (!skcrl && crl)
goto done;
get_crl_sk(ctx, &crl, &dcrl, &issuer, &crl_score, &reasons, skcrl);
sk_X509_CRL_pop_free(skcrl, X509_CRL_free);
done:
/* If we got any kind of CRL use it and return success */
if (crl) {
ctx->current_issuer = issuer;
ctx->current_crl_score = crl_score;
ctx->current_reasons = reasons;
*pcrl = crl;
*pdcrl = dcrl;
return 1;
}
return 0;
}
|
CWE-254
| 5,044 | 14,307 |
142306268328871760637992100308490315544
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int get_crl_score(X509_STORE_CTX *ctx, X509 **pissuer,
unsigned int *preasons, X509_CRL *crl, X509 *x)
{
int crl_score = 0;
unsigned int tmp_reasons = *preasons, crl_reasons;
/* First see if we can reject CRL straight away */
/* Invalid IDP cannot be processed */
if (crl->idp_flags & IDP_INVALID)
return 0;
/* Reason codes or indirect CRLs need extended CRL support */
if (!(ctx->param->flags & X509_V_FLAG_EXTENDED_CRL_SUPPORT)) {
if (crl->idp_flags & (IDP_INDIRECT | IDP_REASONS))
return 0;
} else if (crl->idp_flags & IDP_REASONS) {
/* If no new reasons reject */
if (!(crl->idp_reasons & ~tmp_reasons))
return 0;
}
/* Don't process deltas at this stage */
else if (crl->base_crl_number)
return 0;
/* If issuer name doesn't match certificate need indirect CRL */
if (X509_NAME_cmp(X509_get_issuer_name(x), X509_CRL_get_issuer(crl))) {
if (!(crl->idp_flags & IDP_INDIRECT))
return 0;
} else
crl_score |= CRL_SCORE_ISSUER_NAME;
if (!(crl->flags & EXFLAG_CRITICAL))
crl_score |= CRL_SCORE_NOCRITICAL;
/* Check expiry */
if (check_crl_time(ctx, crl, 0))
crl_score |= CRL_SCORE_TIME;
/* Check authority key ID and locate certificate issuer */
crl_akid_check(ctx, crl, pissuer, &crl_score);
/* If we can't locate certificate issuer at this point forget it */
if (!(crl_score & CRL_SCORE_AKID))
return 0;
/* Check cert for matching CRL distribution points */
if (crl_crldp_check(x, crl, crl_score, &crl_reasons)) {
/* If no new reasons reject */
if (!(crl_reasons & ~tmp_reasons))
return 0;
tmp_reasons |= crl_reasons;
crl_score |= CRL_SCORE_SCOPE;
}
*preasons = tmp_reasons;
return crl_score;
}
|
CWE-254
| 5,045 | 14,308 |
87584633249262420159093621394877638909
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static void get_delta_sk(X509_STORE_CTX *ctx, X509_CRL **dcrl, int *pscore,
X509_CRL *base, STACK_OF(X509_CRL) *crls)
{
X509_CRL *delta;
int i;
if (!(ctx->param->flags & X509_V_FLAG_USE_DELTAS))
return;
if (!((ctx->current_cert->ex_flags | base->flags) & EXFLAG_FRESHEST))
return;
for (i = 0; i < sk_X509_CRL_num(crls); i++) {
delta = sk_X509_CRL_value(crls, i);
if (check_delta_base(delta, base)) {
if (check_crl_time(ctx, delta, 0))
*pscore |= CRL_SCORE_TIME_DELTA;
CRYPTO_add(&delta->references, 1, CRYPTO_LOCK_X509_CRL);
*dcrl = delta;
return;
}
}
*dcrl = NULL;
}
|
CWE-254
| 5,047 | 14,309 |
203303882260281175919691558652184196163
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int get_issuer_sk(X509 **issuer, X509_STORE_CTX *ctx, X509 *x)
{
*issuer = find_issuer(ctx, ctx->other_ctx, x);
if (*issuer) {
CRYPTO_add(&(*issuer)->references, 1, CRYPTO_LOCK_X509);
return 1;
} else
return 0;
}
|
CWE-254
| 5,048 | 14,310 |
8260738838227041572108086059530467490
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int idp_check_dp(DIST_POINT_NAME *a, DIST_POINT_NAME *b)
{
X509_NAME *nm = NULL;
GENERAL_NAMES *gens = NULL;
GENERAL_NAME *gena, *genb;
int i, j;
if (!a || !b)
return 1;
if (a->type == 1) {
if (!a->dpname)
return 0;
/* Case 1: two X509_NAME */
if (b->type == 1) {
if (!b->dpname)
return 0;
if (!X509_NAME_cmp(a->dpname, b->dpname))
return 1;
else
return 0;
}
/* Case 2: set name and GENERAL_NAMES appropriately */
nm = a->dpname;
gens = b->name.fullname;
} else if (b->type == 1) {
if (!b->dpname)
return 0;
/* Case 2: set name and GENERAL_NAMES appropriately */
gens = a->name.fullname;
nm = b->dpname;
}
/* Handle case 2 with one GENERAL_NAMES and one X509_NAME */
if (nm) {
for (i = 0; i < sk_GENERAL_NAME_num(gens); i++) {
gena = sk_GENERAL_NAME_value(gens, i);
if (gena->type != GEN_DIRNAME)
continue;
if (!X509_NAME_cmp(nm, gena->d.directoryName))
return 1;
}
return 0;
}
/* Else case 3: two GENERAL_NAMES */
for (i = 0; i < sk_GENERAL_NAME_num(a->name.fullname); i++) {
gena = sk_GENERAL_NAME_value(a->name.fullname, i);
for (j = 0; j < sk_GENERAL_NAME_num(b->name.fullname); j++) {
genb = sk_GENERAL_NAME_value(b->name.fullname, j);
if (!GENERAL_NAME_cmp(gena, genb))
return 1;
}
}
return 0;
}
|
CWE-254
| 5,049 | 14,311 |
319651222474677689607084732609996262672
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int internal_verify(X509_STORE_CTX *ctx)
{
int ok = 0, n;
X509 *xs, *xi;
EVP_PKEY *pkey = NULL;
int (*cb) (int xok, X509_STORE_CTX *xctx);
cb = ctx->verify_cb;
n = sk_X509_num(ctx->chain);
ctx->error_depth = n - 1;
n--;
xi = sk_X509_value(ctx->chain, n);
if (ctx->check_issued(ctx, xi, xi))
xs = xi;
else {
if (n <= 0) {
ctx->error = X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE;
ctx->current_cert = xi;
ok = cb(0, ctx);
goto end;
} else {
n--;
ctx->error_depth = n;
xs = sk_X509_value(ctx->chain, n);
}
}
/* ctx->error=0; not needed */
while (n >= 0) {
ctx->error_depth = n;
/*
* Skip signature check for self signed certificates unless
* explicitly asked for. It doesn't add any security and just wastes
* time.
*/
if (!xs->valid
&& (xs != xi
|| (ctx->param->flags & X509_V_FLAG_CHECK_SS_SIGNATURE))) {
if ((pkey = X509_get_pubkey(xi)) == NULL) {
ctx->error = X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY;
ctx->current_cert = xi;
ok = (*cb) (0, ctx);
if (!ok)
goto end;
} else if (X509_verify(xs, pkey) <= 0) {
ctx->error = X509_V_ERR_CERT_SIGNATURE_FAILURE;
ctx->current_cert = xs;
ok = (*cb) (0, ctx);
if (!ok) {
EVP_PKEY_free(pkey);
goto end;
}
}
EVP_PKEY_free(pkey);
pkey = NULL;
}
xs->valid = 1;
ok = check_cert_time(ctx, xs);
if (!ok)
goto end;
/* The last error (if any) is still in the error value */
ctx->current_issuer = xi;
ctx->current_cert = xs;
ok = (*cb) (1, ctx);
if (!ok)
goto end;
n--;
if (n >= 0) {
xi = xs;
xs = sk_X509_value(ctx->chain, n);
}
}
ok = 1;
end:
return ok;
}
|
CWE-254
| 5,050 | 14,312 |
55869176655547011286148452027311580288
| null | null | null |
openssl
|
9a0db453ba017ebcaccbee933ee6511a9ae4d1c8
| 0 |
static int null_callback(int ok, X509_STORE_CTX *e)
{
return ok;
}
|
CWE-254
| 5,051 | 14,313 |
71376723023000961254857181202474008798
| null | null | null |
savannah
|
83a95bd8c8561875b948cadd417c653dbe7ef2e2
| 0 |
bm_delta2_search (char const **tpp, char const *ep, char const *sp, int len,
char const *trans, char gc1, char gc2,
unsigned char const *d1, kwset_t kwset)
{
char const *tp = *tpp;
int d = len, skip = 0;
while (true)
{
int i = 2;
if (tr (trans, tp[-2]) == gc2)
{
while (++i <= d)
if (tr (trans, tp[-i]) != tr (trans, sp[-i]))
break;
if (i > d)
{
for (i = d + skip + 1; i <= len; ++i)
if (tr (trans, tp[-i]) != tr (trans, sp[-i]))
break;
if (i > len)
{
*tpp = tp - len;
return true;
}
}
}
tp += d = kwset->shift[i - 2];
if (tp > ep)
break;
if (tr (trans, tp[-1]) != gc1)
{
if (d1)
tp += d1[U(tp[-1])];
break;
}
skip = i - 1;
}
*tpp = tp;
return false;
}
|
CWE-119
| 5,266 | 14,331 |
248038147892686120557582572352021251358
| null | null | null |
savannah
|
83a95bd8c8561875b948cadd417c653dbe7ef2e2
| 0 |
bmexec (kwset_t kwset, char const *text, size_t size)
{
/* Help the compiler inline bmexec_trans in two ways, depending on
whether kwset->trans is null. */
return (kwset->trans
? bmexec_trans (kwset, text, size)
: bmexec_trans (kwset, text, size));
}
|
CWE-119
| 5,267 | 14,332 |
292497658767064056094464719399494622711
| null | null | null |
savannah
|
83a95bd8c8561875b948cadd417c653dbe7ef2e2
| 0 |
cwexec (kwset_t kwset, char const *text, size_t len, struct kwsmatch *kwsmatch)
{
struct trie * const *next;
struct trie const *trie;
struct trie const *accept;
char const *beg, *lim, *mch, *lmch;
unsigned char c;
unsigned char const *delta;
int d;
char const *end, *qlim;
struct tree const *tree;
char const *trans;
#ifdef lint
accept = NULL;
#endif
/* Initialize register copies and look for easy ways out. */
if (len < kwset->mind)
return -1;
next = kwset->next;
delta = kwset->delta;
trans = kwset->trans;
lim = text + len;
end = text;
if ((d = kwset->mind) != 0)
mch = NULL;
else
{
mch = text, accept = kwset->trie;
goto match;
}
if (len >= 4 * kwset->mind)
qlim = lim - 4 * kwset->mind;
else
qlim = NULL;
while (lim - end >= d)
{
if (qlim && end <= qlim)
{
end += d - 1;
while ((d = delta[c = *end]) && end < qlim)
{
end += d;
end += delta[U(*end)];
end += delta[U(*end)];
}
++end;
}
else
d = delta[c = (end += d)[-1]];
if (d)
continue;
beg = end - 1;
trie = next[c];
if (trie->accepting)
{
mch = beg;
accept = trie;
}
d = trie->shift;
while (beg > text)
{
unsigned char uc = *--beg;
c = trans ? trans[uc] : uc;
tree = trie->links;
while (tree && c != tree->label)
if (c < tree->label)
tree = tree->llink;
else
tree = tree->rlink;
if (tree)
{
trie = tree->trie;
if (trie->accepting)
{
mch = beg;
accept = trie;
}
}
else
break;
d = trie->shift;
}
if (mch)
goto match;
}
return -1;
match:
/* Given a known match, find the longest possible match anchored
at or before its starting point. This is nearly a verbatim
copy of the preceding main search loops. */
if (lim - mch > kwset->maxd)
lim = mch + kwset->maxd;
lmch = 0;
d = 1;
while (lim - end >= d)
{
if ((d = delta[c = (end += d)[-1]]) != 0)
continue;
beg = end - 1;
if (!(trie = next[c]))
{
d = 1;
continue;
}
if (trie->accepting && beg <= mch)
{
lmch = beg;
accept = trie;
}
d = trie->shift;
while (beg > text)
{
unsigned char uc = *--beg;
c = trans ? trans[uc] : uc;
tree = trie->links;
while (tree && c != tree->label)
if (c < tree->label)
tree = tree->llink;
else
tree = tree->rlink;
if (tree)
{
trie = tree->trie;
if (trie->accepting && beg <= mch)
{
lmch = beg;
accept = trie;
}
}
else
break;
d = trie->shift;
}
if (lmch)
{
mch = lmch;
goto match;
}
if (!d)
d = 1;
}
kwsmatch->index = accept->accepting / 2;
kwsmatch->offset[0] = mch - text;
kwsmatch->size[0] = accept->depth;
return mch - text;
}
|
CWE-119
| 5,268 | 14,333 |
213346681780103461433013498608884034773
| null | null | null |
savannah
|
83a95bd8c8561875b948cadd417c653dbe7ef2e2
| 0 |
hasevery (struct tree const *a, struct tree const *b)
{
if (!b)
return 1;
if (!hasevery(a, b->llink))
return 0;
if (!hasevery(a, b->rlink))
return 0;
while (a && b->label != a->label)
if (b->label < a->label)
a = a->llink;
else
a = a->rlink;
return !!a;
}
|
CWE-119
| 5,270 | 14,334 |
276804131193109284478884664279926631315
| null | null | null |
savannah
|
83a95bd8c8561875b948cadd417c653dbe7ef2e2
| 0 |
kwsalloc (char const *trans)
{
struct kwset *kwset = xmalloc (sizeof *kwset);
obstack_init (&kwset->obstack);
kwset->words = 0;
kwset->trie = obstack_alloc (&kwset->obstack, sizeof *kwset->trie);
kwset->trie->accepting = 0;
kwset->trie->links = NULL;
kwset->trie->parent = NULL;
kwset->trie->next = NULL;
kwset->trie->fail = NULL;
kwset->trie->depth = 0;
kwset->trie->shift = 0;
kwset->mind = INT_MAX;
kwset->maxd = -1;
kwset->target = NULL;
kwset->trans = trans;
return kwset;
}
|
CWE-119
| 5,271 | 14,335 |
56386712440139549518911752863728923555
| null | null | null |
savannah
|
83a95bd8c8561875b948cadd417c653dbe7ef2e2
| 0 |
kwsfree (kwset_t kwset)
{
obstack_free (&kwset->obstack, NULL);
free (kwset);
}
|
CWE-119
| 5,272 | 14,336 |
162399315120373808175590445597096331777
| null | null | null |
savannah
|
83a95bd8c8561875b948cadd417c653dbe7ef2e2
| 0 |
kwsincr (kwset_t kwset, char const *text, size_t len)
{
struct trie *trie = kwset->trie;
char const *trans = kwset->trans;
text += len;
/* Descend the trie (built of reversed keywords) character-by-character,
installing new nodes when necessary. */
while (len--)
{
unsigned char uc = *--text;
unsigned char label = trans ? trans[uc] : uc;
/* Descend the tree of outgoing links for this trie node,
looking for the current character and keeping track
of the path followed. */
struct tree *link = trie->links;
struct tree *links[DEPTH_SIZE];
enum { L, R } dirs[DEPTH_SIZE];
links[0] = (struct tree *) &trie->links;
dirs[0] = L;
int depth = 1;
while (link && label != link->label)
{
links[depth] = link;
if (label < link->label)
dirs[depth++] = L, link = link->llink;
else
dirs[depth++] = R, link = link->rlink;
}
/* The current character doesn't have an outgoing link at
this trie node, so build a new trie node and install
a link in the current trie node's tree. */
if (!link)
{
link = obstack_alloc (&kwset->obstack, sizeof *link);
link->llink = NULL;
link->rlink = NULL;
link->trie = obstack_alloc (&kwset->obstack, sizeof *link->trie);
link->trie->accepting = 0;
link->trie->links = NULL;
link->trie->parent = trie;
link->trie->next = NULL;
link->trie->fail = NULL;
link->trie->depth = trie->depth + 1;
link->trie->shift = 0;
link->label = label;
link->balance = 0;
/* Install the new tree node in its parent. */
if (dirs[--depth] == L)
links[depth]->llink = link;
else
links[depth]->rlink = link;
/* Back up the tree fixing the balance flags. */
while (depth && !links[depth]->balance)
{
if (dirs[depth] == L)
--links[depth]->balance;
else
++links[depth]->balance;
--depth;
}
/* Rebalance the tree by pointer rotations if necessary. */
if (depth && ((dirs[depth] == L && --links[depth]->balance)
|| (dirs[depth] == R && ++links[depth]->balance)))
{
struct tree *t, *r, *l, *rl, *lr;
switch (links[depth]->balance)
{
case (char) -2:
switch (dirs[depth + 1])
{
case L:
r = links[depth], t = r->llink, rl = t->rlink;
t->rlink = r, r->llink = rl;
t->balance = r->balance = 0;
break;
case R:
r = links[depth], l = r->llink, t = l->rlink;
rl = t->rlink, lr = t->llink;
t->llink = l, l->rlink = lr, t->rlink = r, r->llink = rl;
l->balance = t->balance != 1 ? 0 : -1;
r->balance = t->balance != (char) -1 ? 0 : 1;
t->balance = 0;
break;
default:
abort ();
}
break;
case 2:
switch (dirs[depth + 1])
{
case R:
l = links[depth], t = l->rlink, lr = t->llink;
t->llink = l, l->rlink = lr;
t->balance = l->balance = 0;
break;
case L:
l = links[depth], r = l->rlink, t = r->llink;
lr = t->llink, rl = t->rlink;
t->llink = l, l->rlink = lr, t->rlink = r, r->llink = rl;
l->balance = t->balance != 1 ? 0 : -1;
r->balance = t->balance != (char) -1 ? 0 : 1;
t->balance = 0;
break;
default:
abort ();
}
break;
default:
abort ();
}
if (dirs[depth - 1] == L)
links[depth - 1]->llink = t;
else
links[depth - 1]->rlink = t;
}
}
trie = link->trie;
}
/* Mark the node we finally reached as accepting, encoding the
index number of this word in the keyword set so far. */
if (!trie->accepting)
trie->accepting = 1 + 2 * kwset->words;
++kwset->words;
/* Keep track of the longest and shortest string of the keyword set. */
if (trie->depth < kwset->mind)
kwset->mind = trie->depth;
if (trie->depth > kwset->maxd)
kwset->maxd = trie->depth;
}
|
CWE-119
| 5,273 | 14,337 |
262976692931494638056673589975121195823
| null | null | null |
savannah
|
83a95bd8c8561875b948cadd417c653dbe7ef2e2
| 0 |
kwsprep (kwset_t kwset)
{
char const *trans = kwset->trans;
int i;
unsigned char deltabuf[NCHAR];
unsigned char *delta = trans ? deltabuf : kwset->delta;
/* Initial values for the delta table; will be changed later. The
delta entry for a given character is the smallest depth of any
node at which an outgoing edge is labeled by that character. */
memset (delta, MIN (kwset->mind, UCHAR_MAX), sizeof deltabuf);
/* Traverse the nodes of the trie in level order, simultaneously
computing the delta table, failure function, and shift function. */
struct trie *curr, *last;
for (curr = last = kwset->trie; curr; curr = curr->next)
{
/* Enqueue the immediate descendants in the level order queue. */
enqueue (curr->links, &last);
curr->shift = kwset->mind;
curr->maxshift = kwset->mind;
/* Update the delta table for the descendants of this node. */
treedelta (curr->links, curr->depth, delta);
/* Compute the failure function for the descendants of this node. */
treefails (curr->links, curr->fail, kwset->trie);
/* Update the shifts at each node in the current node's chain
of fails back to the root. */
struct trie *fail;
for (fail = curr->fail; fail; fail = fail->fail)
{
/* If the current node has some outgoing edge that the fail
doesn't, then the shift at the fail should be no larger
than the difference of their depths. */
if (!hasevery (fail->links, curr->links))
if (curr->depth - fail->depth < fail->shift)
fail->shift = curr->depth - fail->depth;
/* If the current node is accepting then the shift at the
fail and its descendants should be no larger than the
difference of their depths. */
if (curr->accepting && fail->maxshift > curr->depth - fail->depth)
fail->maxshift = curr->depth - fail->depth;
}
}
/* Traverse the trie in level order again, fixing up all nodes whose
shift exceeds their inherited maxshift. */
for (curr = kwset->trie->next; curr; curr = curr->next)
{
if (curr->maxshift > curr->parent->maxshift)
curr->maxshift = curr->parent->maxshift;
if (curr->shift > curr->maxshift)
curr->shift = curr->maxshift;
}
/* Create a vector, indexed by character code, of the outgoing links
from the root node. */
struct trie *nextbuf[NCHAR];
struct trie **next = trans ? nextbuf : kwset->next;
memset (next, 0, sizeof nextbuf);
treenext (kwset->trie->links, next);
if (trans)
for (i = 0; i < NCHAR; ++i)
kwset->next[i] = next[U(trans[i])];
/* Check if we can use the simple boyer-moore algorithm, instead
of the hairy commentz-walter algorithm. */
if (kwset->words == 1)
{
/* Looking for just one string. Extract it from the trie. */
kwset->target = obstack_alloc (&kwset->obstack, kwset->mind);
for (i = kwset->mind - 1, curr = kwset->trie; i >= 0; --i)
{
kwset->target[i] = curr->links->label;
curr = curr->next;
}
/* Looking for the delta2 shift that we might make after a
backwards match has failed. Extract it from the trie. */
if (kwset->mind > 1)
{
kwset->shift
= obstack_alloc (&kwset->obstack,
sizeof *kwset->shift * (kwset->mind - 1));
for (i = 0, curr = kwset->trie->next; i < kwset->mind - 1; ++i)
{
kwset->shift[i] = curr->shift;
curr = curr->next;
}
}
char gc1 = tr (trans, kwset->target[kwset->mind - 1]);
/* Set GC1HELP according to whether exactly one, exactly two, or
three-or-more characters match GC1. */
int gc1help = -1;
if (trans)
{
char const *equiv1 = memchr (trans, gc1, NCHAR);
char const *equiv2 = memchr (equiv1 + 1, gc1,
trans + NCHAR - (equiv1 + 1));
if (equiv2)
gc1help = (memchr (equiv2 + 1, gc1, trans + NCHAR - (equiv2 + 1))
? NCHAR
: U(gc1) ^ (equiv1 - trans) ^ (equiv2 - trans));
}
kwset->gc1 = gc1;
kwset->gc1help = gc1help;
if (kwset->mind > 1)
kwset->gc2 = tr (trans, kwset->target[kwset->mind - 2]);
}
/* Fix things up for any translation table. */
if (trans)
for (i = 0; i < NCHAR; ++i)
kwset->delta[i] = delta[U(trans[i])];
}
|
CWE-119
| 5,274 | 14,338 |
208552495791208373828101975714868720504
| null | null | null |
savannah
|
83a95bd8c8561875b948cadd417c653dbe7ef2e2
| 0 |
memchr_kwset (char const *s, size_t n, kwset_t kwset)
{
if (kwset->gc1help < 0)
return memchr (s, kwset->gc1, n);
int small_heuristic = 2;
int small = (- (uintptr_t) s % sizeof (long)
+ small_heuristic * sizeof (long));
size_t ntrans = kwset->gc1help < NCHAR && small < n ? small : n;
char const *slim = s + ntrans;
for (; s < slim; s++)
if (kwset->trans[U(*s)] == kwset->gc1)
return s;
n -= ntrans;
return n == 0 ? NULL : memchr2 (s, kwset->gc1, kwset->gc1help, n);
}
|
CWE-119
| 5,275 | 14,339 |
18099728818456118904484656803665974941
| null | null | null |
savannah
|
83a95bd8c8561875b948cadd417c653dbe7ef2e2
| 0 |
tr (char const *trans, char c)
{
return trans ? trans[U(c)] : c;
}
|
CWE-119
| 5,276 | 14,340 |
248311837724717727698702247837903921085
| null | null | null |
savannah
|
83a95bd8c8561875b948cadd417c653dbe7ef2e2
| 0 |
treedelta (struct tree const *tree,
unsigned int depth,
unsigned char delta[])
{
if (!tree)
return;
treedelta(tree->llink, depth, delta);
treedelta(tree->rlink, depth, delta);
if (depth < delta[tree->label])
delta[tree->label] = depth;
}
|
CWE-119
| 5,277 | 14,341 |
238560226702049615856933608011799233351
| null | null | null |
savannah
|
83a95bd8c8561875b948cadd417c653dbe7ef2e2
| 0 |
treefails (struct tree const *tree, struct trie const *fail,
struct trie *recourse)
{
struct tree *link;
if (!tree)
return;
treefails(tree->llink, fail, recourse);
treefails(tree->rlink, fail, recourse);
/* Find, in the chain of fails going back to the root, the first
node that has a descendant on the current label. */
while (fail)
{
link = fail->links;
while (link && tree->label != link->label)
if (tree->label < link->label)
link = link->llink;
else
link = link->rlink;
if (link)
{
tree->trie->fail = link->trie;
return;
}
fail = fail->fail;
}
tree->trie->fail = recourse;
}
|
CWE-119
| 5,278 | 14,342 |
266410234267996709226524414480031205213
| null | null | null |
savannah
|
83a95bd8c8561875b948cadd417c653dbe7ef2e2
| 0 |
treenext (struct tree const *tree, struct trie *next[])
{
if (!tree)
return;
treenext(tree->llink, next);
treenext(tree->rlink, next);
next[tree->label] = tree->trie;
}
|
CWE-119
| 5,279 | 14,343 |
204460611724618482556541927885585036151
| null | null | null |
harfbuzz
|
a6a79df5fe2ed2cd307e7a991346faee164e70d9
| 0 |
hb_buffer_destroy (hb_buffer_t *buffer)
{
HB_OBJECT_DO_DESTROY (buffer);
hb_unicode_funcs_destroy (buffer->unicode);
free (buffer->info);
free (buffer->pos);
free (buffer);
}
| 5,285 | 14,347 |
139667113007239449149484418753563423163
| null | null | null |
|
harfbuzz
|
a6a79df5fe2ed2cd307e7a991346faee164e70d9
| 0 |
hb_buffer_get_direction (hb_buffer_t *buffer)
{
return buffer->direction;
}
| 5,286 | 14,348 |
209146125016122585166047227658344967450
| null | null | null |
|
harfbuzz
|
a6a79df5fe2ed2cd307e7a991346faee164e70d9
| 0 |
hb_buffer_get_reference_count (hb_buffer_t *buffer)
{
HB_OBJECT_DO_GET_REFERENCE_COUNT (buffer);
}
| 5,288 | 14,349 |
97921560959633711695762929871254554503
| null | null | null |
|
harfbuzz
|
a6a79df5fe2ed2cd307e7a991346faee164e70d9
| 0 |
hb_buffer_get_script (hb_buffer_t *buffer)
{
return buffer->script;
}
| 5,289 | 14,350 |
307872008849091557821949058398436763406
| null | null | null |
|
harfbuzz
|
a6a79df5fe2ed2cd307e7a991346faee164e70d9
| 0 |
hb_buffer_get_unicode_funcs (hb_buffer_t *buffer)
{
return buffer->unicode;
}
| 5,290 | 14,351 |
102109335274691151903466904309110558398
| null | null | null |
|
harfbuzz
|
a6a79df5fe2ed2cd307e7a991346faee164e70d9
| 0 |
hb_buffer_reference (hb_buffer_t *buffer)
{
HB_OBJECT_DO_REFERENCE (buffer);
}
| 5,291 | 14,352 |
239348656081988781959139061011491187197
| null | null | null |
|
harfbuzz
|
a6a79df5fe2ed2cd307e7a991346faee164e70d9
| 0 |
hb_buffer_set_direction (hb_buffer_t *buffer,
hb_direction_t direction)
{
buffer->direction = direction;
}
| 5,292 | 14,353 |
199702388474071334730476784740730461851
| null | null | null |
|
harfbuzz
|
a6a79df5fe2ed2cd307e7a991346faee164e70d9
| 0 |
hb_buffer_set_script (hb_buffer_t *buffer,
hb_script_t script)
{
buffer->script = script;
}
| 5,293 | 14,354 |
275574185326423248050635076136625559099
| null | null | null |
|
harfbuzz
|
a6a79df5fe2ed2cd307e7a991346faee164e70d9
| 0 |
hb_buffer_set_unicode_funcs (hb_buffer_t *buffer,
hb_unicode_funcs_t *unicode)
{
if (!unicode)
unicode = &_hb_unicode_funcs_nil;
hb_unicode_funcs_reference (unicode);
hb_unicode_funcs_destroy (buffer->unicode);
buffer->unicode = unicode;
}
| 5,294 | 14,355 |
29017524112433670717619381779911676273
| null | null | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.