code
stringlengths 23
2.05k
| label_name
stringlengths 6
7
| label
int64 0
37
|
|---|---|---|
.on("finished", () => {
if (doTraceChunk) {
// tslint:disable-next-line: no-console
warningLog(
timestamp(),
" <$$ ",
msgType,
"nbChunk = " + nbChunks.toString().padStart(3),
"totalLength = " + totalSize.toString().padStart(8),
"l=",
binSize.toString().padStart(6)
);
}
if (totalSize > this.maxMessageSize) {
errorLog(`[NODE-OPCUA-E55] message size ${totalSize} exceeds the negotiated message size ${this.maxMessageSize} nb chunks ${nbChunks}`);
}
messageChunkCallback(null);
}); | CWE-400 | 2 |
export async function getApi(newToken?: string) {
const token = newToken || (await getToken());
const apiurl = config.get("apiUrl");
return new GitHub({ apiurl, token });
} | CWE-863 | 11 |
constructor() {
super();
this.name = this.constructor.name + counter;
counter += 1;
this._timerId = null;
this._timeout = 30000; // 30 seconds timeout
this._socket = null;
this.headerSize = 8;
this.protocolVersion = 0;
this._disconnecting = false;
this._pendingBuffer = undefined;
this.bytesWritten = 0;
this.bytesRead = 0;
this._theCallback = undefined;
this.chunkWrittenCount = 0;
this.chunkReadCount = 0;
this._onSocketClosedHasBeenCalled = false;
this._onSocketEndedHasBeenCalled = false;
TCP_transport.registry.register(this);
} | CWE-400 | 2 |
private onWebSocket(req, socket, websocket) {
websocket.on("error", onUpgradeError);
if (
transports[req._query.transport] !== undefined &&
!transports[req._query.transport].prototype.handlesUpgrades
) {
debug("transport doesnt handle upgraded requests");
websocket.close();
return;
}
// get client id
const id = req._query.sid;
// keep a reference to the ws.Socket
req.websocket = websocket;
if (id) {
const client = this.clients[id];
if (!client) {
debug("upgrade attempt for closed client");
websocket.close();
} else if (client.upgrading) {
debug("transport has already been trying to upgrade");
websocket.close();
} else if (client.upgraded) {
debug("transport had already been upgraded");
websocket.close();
} else {
debug("upgrading existing transport");
// transport error handling takes over
websocket.removeListener("error", onUpgradeError);
const transport = this.createTransport(req._query.transport, req);
if (req._query && req._query.b64) {
transport.supportsBinary = false;
} else {
transport.supportsBinary = true;
}
transport.perMessageDeflate = this.opts.perMessageDeflate;
client.maybeUpgrade(transport);
}
} else {
// transport error handling takes over
websocket.removeListener("error", onUpgradeError);
const closeConnection = (errorCode, errorContext) =>
abortUpgrade(socket, errorCode, errorContext);
this.handshake(req._query.transport, req, closeConnection);
}
function onUpgradeError() {
debug("websocket error before upgrade");
// websocket.close() not needed
}
} | CWE-754 | 31 |
private _buildData(data: Buffer) {
if (data && this._stack.length === 0) {
return data;
}
if (!data && this._stack.length === 1) {
data = this._stack[0];
this._stack.length = 0; // empty stack array
return data;
}
this._stack.push(data);
data = Buffer.concat(this._stack);
this._stack.length = 0;
return data;
} | CWE-400 | 2 |
'X-Parse-Session-Token': user5.getSessionToken(),
})
).data.find.edges.map((object) => object.node.someField)
).toEqual(['someValue3']);
}); | CWE-863 | 11 |
const uploader = multer({ dest: path.join(__dirname, '.upload'), limits: { fileSize: 1024 ** 3 }, ...options.multer }).any()
app.get(`${basePath}/`, [
hooks0.onRequest,
ctrlHooks0.onRequest,
createValidateHandler(req => [
Object.keys(req.query).length ? validateOrReject(Object.assign(new Validators.Query(), req.query), validatorOptions) : null
]),
asyncMethodToHandler(controller0.get)
])
app.post(`${basePath}/`, [
hooks0.onRequest,
ctrlHooks0.onRequest,
uploader,
formatMulterData([]),
createValidateHandler(req => [
validateOrReject(Object.assign(new Validators.Query(), req.query), validatorOptions),
validateOrReject(Object.assign(new Validators.Body(), req.body), validatorOptions)
]),
methodToHandler(controller0.post)
])
app.get(`${basePath}/empty/noEmpty`, [
hooks0.onRequest,
methodToHandler(controller1.get)
])
app.post(`${basePath}/multiForm`, [
hooks0.onRequest,
uploader,
formatMulterData([['empty', false], ['vals', false], ['files', false]]),
createValidateHandler(req => [
validateOrReject(Object.assign(new Validators.MultiForm(), req.body), validatorOptions)
]),
methodToHandler(controller2.post)
])
app.get(`${basePath}/texts`, [
hooks0.onRequest,
methodToHandler(controller3.get)
])
app.put(`${basePath}/texts`, [
hooks0.onRequest,
methodToHandler(controller3.put)
])
app.put(`${basePath}/texts/sample`, [
hooks0.onRequest,
parseJSONBoby,
methodToHandler(controller4.put)
])
app.get(`${basePath}/users`, [
hooks0.onRequest,
hooks1.onRequest,
...ctrlHooks1.preHandler,
asyncMethodToHandler(controller5.get)
])
app.post(`${basePath}/users`, [
hooks0.onRequest,
hooks1.onRequest,
parseJSONBoby,
createValidateHandler(req => [
validateOrReject(Object.assign(new Validators.UserInfo(), req.body), validatorOptions)
]),
...ctrlHooks1.preHandler,
methodToHandler(controller5.post)
])
return app
} | CWE-20 | 0 |
WebContents.prototype.sendToFrame = function (frameId, channel, ...args) {
if (typeof channel !== 'string') {
throw new Error('Missing required channel argument');
} else if (typeof frameId !== 'number') {
throw new Error('Missing required frameId argument');
}
return this._sendToFrame(false /* internal */, frameId, channel, args);
}; | CWE-668 | 7 |
on(eventName: "message", eventHandler: (message: Buffer) => void): this; | CWE-400 | 2 |
) => {
if (!info || !info.sessionToken) {
throw new Parse.Error(
Parse.Error.INVALID_SESSION_TOKEN,
'Invalid session token'
);
}
const sessionToken = info.sessionToken;
const selectedFields = getFieldNames(queryInfo)
.filter(field => field.startsWith(keysPrefix))
.map(field => field.replace(keysPrefix, ''));
const keysAndInclude = extractKeysAndInclude(selectedFields);
const { keys } = keysAndInclude;
let { include } = keysAndInclude;
if (validatedToken && !keys && !include) {
return {
sessionToken,
};
} else if (keys && !include) {
include = 'user';
}
const options = {};
if (keys) {
options.keys = keys
.split(',')
.map(key => `user.${key}`)
.join(',');
}
if (include) {
options.include = include
.split(',')
.map(included => `user.${included}`)
.join(',');
}
const response = await rest.find(
config,
Auth.master(config),
'_Session',
{ sessionToken },
options,
info.clientVersion,
info.context,
);
if (
!response.results ||
response.results.length == 0 ||
!response.results[0].user
) {
throw new Parse.Error(
Parse.Error.INVALID_SESSION_TOKEN,
'Invalid session token'
);
} else {
const user = response.results[0].user;
return {
sessionToken,
user,
};
}
}; | CWE-863 | 11 |
updateOidcSettings(configuration) {
checkAdminAuthentication(this)
ServiceConfiguration.configurations.remove({
service: 'oidc',
})
ServiceConfiguration.configurations.insert(configuration)
} | CWE-285 | 23 |
get: (path) => {
useCount++;
expect(path).toEqual('somepath');
}, | CWE-863 | 11 |
let getNftParentId = async (tokenIdHex: string) => {
let txnhex = (await asyncSlpValidator.getRawTransactions([tokenIdHex]))[0];
let tx = Primatives.Transaction.parseFromBuffer(Buffer.from(txnhex, 'hex'));
let nftBurnTxnHex = (await asyncSlpValidator.getRawTransactions([tx.inputs[0].previousTxHash]))[0];
let nftBurnTxn = Primatives.Transaction.parseFromBuffer(Buffer.from(nftBurnTxnHex, 'hex'));
let slp = new Slp(this.BITBOX);
let nftBurnSlp = slp.parseSlpOutputScript(Buffer.from(nftBurnTxn.outputs[0].scriptPubKey));
if (nftBurnSlp.transactionType === SlpTransactionType.GENESIS) {
return tx.inputs[0].previousTxHash;
}
else {
return nftBurnSlp.tokenIdHex;
}
} | CWE-20 | 0 |
constructor(options?: MessageChunkerOptions) {
options = options || {};
this.sequenceNumberGenerator = new SequenceNumberGenerator();
this.maxMessageSize = options.maxMessageSize || 16 *1024*1024;
this.update(options);
} | CWE-400 | 2 |
export type ReadMessageFuncType = (data: Buffer) => PacketInfo; | CWE-400 | 2 |
private _renew_security_token() {
doDebug && debugLog("ClientSecureChannelLayer#_renew_security_token");
// istanbul ignore next
if (!this.isValid()) {
// this may happen if the communication has been closed by the client or the sever
warningLog("Invalid socket => Communication has been lost, cannot renew token");
return;
}
const isInitial = false;
this._open_secure_channel_request(isInitial, (err?: Error | null) => {
/* istanbul ignore else */
if (!err) {
doDebug && debugLog(" token renewed");
/**
* notify the observers that the security has been renewed
* @event security_token_renewed
*/
this.emit("security_token_renewed");
} else {
if (doDebug) {
debugLog("ClientSecureChannelLayer: Warning: securityToken hasn't been renewed -> err ", err);
}
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX CHECK ME !!!
this.closeWithError(new Error("Restarting because Request has timed out during OpenSecureChannel"), () => {
/* */
});
}
});
}
| CWE-400 | 2 |
etsyApiFetch(endpoint, options) {
this._assumeField('endpoint', endpoint);
return new Promise((resolve, reject) => {
const getQueryString = queryString.stringify(this.getOptions(options));
fetch(`${this.apiUrl}${endpoint}?${getQueryString}`)
.then(response => EtsyClient._response(response, resolve, reject))
.catch(reject);
});
}
| CWE-200 | 10 |
componentDidMount () {
this.store.gotoUrl(this.props.params.url);
return this.store.generateToken();
} | CWE-346 | 16 |
async function waitSessionCountChange(currentSessionCountMonitoredItem) {
return await new Promise((resolve,reject) => {
const timer = setTimeout(() => {
reject(new Error("Never received ", currentSessionCountMonitoredItem.toString()));
}, 5000);
currentSessionCountMonitoredItem.once("changed", function (dataValue) {
clearTimeout(timer);
const new_currentSessionCount = dataValue.value.value;
debugLog("new currentSessionCount=", dataValue.toString());
resolve(new_currentSessionCount);
});
});
} | CWE-400 | 2 |
create = (profile) => {
const rockUpdateFields = this.mapApollosFieldsToRock(profile);
return this.post('/People', {
Gender: 0, // required by Rock. Listed first so it can be overridden.
...rockUpdateFields,
IsSystem: false, // required by rock
});
}; | CWE-287 | 4 |
function g_sendError(channel: ServerSecureChannelLayer, message: Message, ResponseClass: any, statusCode: StatusCode): void {
const response = new ResponseClass({
responseHeader: { serviceResult: statusCode }
});
return channel.send_response("MSG", response, message);
} | CWE-400 | 2 |
getScriptOperations(script: Buffer) {
let ops: PushDataOperation[] = [];
try {
let n = 0;
let dlen: number;
while (n < script.length) {
let op: PushDataOperation = { opcode: script[n], data: null }
n += 1;
if(op.opcode <= this.BITBOX.Script.opcodes.OP_PUSHDATA4) {
if(op.opcode < this.BITBOX.Script.opcodes.OP_PUSHDATA1)
dlen = op.opcode;
else if(op.opcode === this.BITBOX.Script.opcodes.OP_PUSHDATA1) {
dlen = script[n];
n += 1;
}
else if(op.opcode === this.BITBOX.Script.opcodes.OP_PUSHDATA2) {
dlen = script.slice(n, n + 2).readUIntLE(0,2);
n += 2;
}
else {
dlen = script.slice(n, n + 4).readUIntLE(0,4);
n += 4;
}
if((n + dlen) > script.length) {
throw Error('IndexError');
}
if(dlen > 0)
op.data = script.slice(n, n + dlen);
n += dlen
}
ops.push(op);
}
} catch(e) {
//console.log(e);
throw Error('truncated script')
}
return ops;
} | CWE-20 | 0 |
export function get(key: "apiUrl"): string;
export function get(key: "images.markdownPasteFormat"): "markdown" | "html"; | CWE-863 | 11 |
buildRawNFT1GenesisTx(config: configBuildRawNFT1GenesisTx, type = 0x01) {
let config2: configBuildRawGenesisTx = {
slpGenesisOpReturn: config.slpNFT1GenesisOpReturn,
mintReceiverAddress: config.mintReceiverAddress,
mintReceiverSatoshis: config.mintReceiverSatoshis,
batonReceiverAddress: null,
bchChangeReceiverAddress: config.bchChangeReceiverAddress,
input_utxos: config.input_utxos,
allowed_token_burning: [ config.parentTokenIdHex ]
}
return this.buildRawGenesisTx(config2);
} | CWE-20 | 0 |
get: (path) => {
useCount++;
expect(path).toEqual('somepath');
},
})
).not.toThrow();
expect(useCount).toBeGreaterThan(0);
}); | CWE-863 | 11 |
userPassword: bcrypt.hashSync(req.body.userPassword, 10),
isAdmin: isAdmin
};
// check for existing user
db.users.findOne({'userEmail': req.body.userEmail}, (err, user) => {
if(user){
// user already exists with that email address
console.error(colors.red('Failed to insert user, possibly already exists: ' + err));
req.session.message = 'A user with that email address already exists';
req.session.messageType = 'danger';
res.redirect('/admin/user/new');
return;
}
// email is ok to be used.
db.users.insert(doc, (err, doc) => {
// show the view
if(err){
if(doc){
console.error(colors.red('Failed to insert user: ' + err));
req.session.message = 'User exists';
req.session.messageType = 'danger';
res.redirect('/admin/user/edit/' + doc._id);
return;
}
console.error(colors.red('Failed to insert user: ' + err));
req.session.message = 'New user creation failed';
req.session.messageType = 'danger';
res.redirect('/admin/user/new');
return;
}
req.session.message = 'User account inserted';
req.session.messageType = 'success';
// if from setup we add user to session and redirect to login.
// Otherwise we show users screen
if(urlParts.path === '/admin/setup'){
req.session.user = req.body.userEmail;
res.redirect('/admin/login');
return;
}
res.redirect('/admin/users');
});
});
}); | CWE-732 | 13 |
constructor(bitbox: BITBOX) {
if(!bitbox)
throw Error("Must provide BITBOX instance to class constructor.")
this.BITBOX = bitbox;
} | CWE-20 | 0 |
static buildSendOpReturn(config: configBuildSendOpReturn, type = 0x01) {
return SlpTokenType1.buildSendOpReturn(
config.tokenIdHex,
config.outputQtyArray,
type
)
} | CWE-20 | 0 |
calculateGenesisCost(genesisOpReturnLength: number, inputUtxoSize: number, batonAddress: string|null, bchChangeAddress?: string, feeRate = 1) {
return this.calculateMintOrGenesisCost(genesisOpReturnLength, inputUtxoSize, batonAddress, bchChangeAddress, feeRate);
} | CWE-20 | 0 |
export function cloneTask(repo: string | undefined, directory: string | undefined, customArgs: string[]): StringTask<string> {
const commands = ['clone', ...customArgs];
if (typeof repo === 'string') {
commands.push(repo);
}
if (typeof directory === 'string') {
commands.push(directory);
}
return straightThroughStringTask(commands);
} | CWE-77 | 14 |
export function exportVariable(name: string, val: any): void {
const convertedVal = toCommandValue(val)
process.env[name] = convertedVal
const filePath = process.env['GITHUB_ENV'] || ''
if (filePath) {
const delimiter = '_GitHubActionsFileCommandDelimeter_'
const commandValue = `${name}<<${delimiter}${os.EOL}${convertedVal}${os.EOL}${delimiter}`
issueFileCommand('ENV', commandValue)
} else {
issueCommand('set-env', {name}, convertedVal)
}
} | CWE-74 | 1 |
use: (path) => {
useCount++;
expect(path).toEqual('somepath');
},
})
).not.toThrow();
expect(useCount).toBeGreaterThan(0);
}); | CWE-863 | 11 |
resetPassword(req) {
const config = req.config;
if (!config) {
this.invalidRequest();
}
if (!config.publicServerURL) {
return this.missingPublicServerURL();
}
const { username, token, new_password } = req.body;
if ((!username || !token || !new_password) && req.xhr === false) {
return this.invalidLink(req);
}
if (!username) {
throw new Parse.Error(Parse.Error.USERNAME_MISSING, 'Missing username');
}
if (!token) {
throw new Parse.Error(Parse.Error.OTHER_CAUSE, 'Missing token');
}
if (!new_password) {
throw new Parse.Error(Parse.Error.PASSWORD_MISSING, 'Missing password');
}
return config.userController
.updatePassword(username, token, new_password)
.then(
() => {
return Promise.resolve({
success: true,
});
},
err => {
return Promise.resolve({
success: false,
err,
});
}
)
.then(result => {
const params = qs.stringify({
username: username,
token: token,
id: config.applicationId,
error: result.err,
app: config.appName,
});
if (req.xhr) {
if (result.success) {
return Promise.resolve({
status: 200,
response: 'Password successfully reset',
});
}
if (result.err) {
throw new Parse.Error(Parse.Error.OTHER_CAUSE, `${result.err}`);
}
}
const encodedUsername = encodeURIComponent(username);
const location = result.success
? `${config.passwordResetSuccessURL}?username=${encodedUsername}`
: `${config.choosePasswordURL}?${params}`;
return Promise.resolve({
status: 302,
location,
});
});
} | CWE-863 | 11 |
Object.keys(req.query as any).length ? validateOrReject(Object.assign(new Validators.Query(), req.query as any), validatorOptions) : null
]) | CWE-20 | 0 |
throw new Error(`Email(s) (${failed.join(", ")}) could not be sent`)
}
}, | CWE-863 | 11 |
event.reply = (...args: any[]) => {
event.sender.sendToFrame(event.frameId, ...args);
}; | CWE-668 | 7 |
this.transport.init(socket, (err?: Error) => {
if (err) {
callback(err);
} else {
this._rememberClientAddressAndPort();
this.messageChunker.maxMessageSize = this.transport.maxMessageSize;
// bind low level TCP transport to messageBuilder
this.transport.on("message", (messageChunk: Buffer) => {
assert(this.messageBuilder);
this.messageBuilder.feed(messageChunk);
});
debugLog("ServerSecureChannelLayer : Transport layer has been initialized");
debugLog("... now waiting for OpenSecureChannelRequest...");
ServerSecureChannelLayer.registry.register(this);
this._wait_for_open_secure_channel_request(callback, this.timeout);
}
}); | CWE-400 | 2 |
async resolve(_source, _args, context, queryInfo) {
try {
const { config, info } = context;
return await getUserFromSessionToken(
config,
info,
queryInfo,
'user.',
false
);
} catch (e) {
parseGraphQLSchema.handleError(e);
}
}, | CWE-863 | 11 |
constructor() {
super();
this._aborted = 0;
this._helloReceived = false;
this.receiveBufferSize = 0;
this.sendBufferSize = 0;
this.maxMessageSize = 0;
this.maxChunkCount = 0;
this.protocolVersion = 0;
} | CWE-400 | 2 |
): Promise<void> => {
event.preventDefault();
if (SingleSignOn.isSingleSignOnLoginWindow(frameName)) {
return new SingleSignOn(main, event, url, options).init();
}
this.logger.log('Opening an external window from a webview.');
return shell.openExternal(url);
}; | CWE-20 | 0 |
verifyEmail(req) {
const { token, username } = req.query;
const appId = req.params.appId;
const config = Config.get(appId);
if (!config) {
this.invalidRequest();
}
if (!config.publicServerURL) {
return this.missingPublicServerURL();
}
if (!token || !username) {
return this.invalidLink(req);
}
const userController = config.userController;
return userController.verifyEmail(username, token).then(
() => {
const params = qs.stringify({ username });
return Promise.resolve({
status: 302,
location: `${config.verifyEmailSuccessURL}?${params}`,
});
},
() => {
return this.invalidVerificationLink(req);
}
);
} | CWE-863 | 11 |
'X-Parse-Session-Token': user1.getSessionToken(),
},
},
});
let foundGraphQLClassReadPreference = false;
let foundUserClassReadPreference = false;
databaseAdapter.database.serverConfig.cursor.calls
.all()
.forEach((call) => {
if (
call.args[0].ns.collection.indexOf('GraphQLClass') >= 0
) {
foundGraphQLClassReadPreference = true;
expect(call.args[0].options.readPreference.mode).toBe(
ReadPreference.PRIMARY
);
} else if (
call.args[0].ns.collection.indexOf('_User') >= 0
) {
foundUserClassReadPreference = true;
expect(call.args[0].options.readPreference.mode).toBe(
ReadPreference.PRIMARY
);
}
});
expect(foundGraphQLClassReadPreference).toBe(true);
expect(foundUserClassReadPreference).toBe(true);
} catch (e) {
handleError(e);
}
}); | CWE-863 | 11 |
isValidUser(username, password) {
const user = users.find(user => user.username === username);
if (!user) return false;
return user.password === password;
} | CWE-400 | 2 |
session: session.fromPartition('about-window'),
spellcheck: false,
webviewTag: false,
},
width: WINDOW_SIZE.WIDTH,
});
aboutWindow.setMenuBarVisibility(false);
// Prevent any kind of navigation
// will-navigate is broken with sandboxed env, intercepting requests instead
// see https://github.com/electron/electron/issues/8841
aboutWindow.webContents.session.webRequest.onBeforeRequest(async ({url}, callback) => {
// Only allow those URLs to be opened within the window
if (ABOUT_WINDOW_ALLOWLIST.includes(url)) {
return callback({cancel: false});
}
// Open HTTPS links in browser instead
if (url.startsWith('https://')) {
await shell.openExternal(url);
} else {
logger.info(`Attempt to open URL "${url}" in window prevented.`);
callback({redirectURL: ABOUT_HTML});
}
});
// Locales
ipcMain.on(EVENT_TYPE.ABOUT.LOCALE_VALUES, (event, labels: locale.i18nLanguageIdentifier[]) => {
if (aboutWindow) {
const isExpected = event.sender.id === aboutWindow.webContents.id;
if (isExpected) {
const resultLabels: Record<string, string> = {};
labels.forEach(label => (resultLabels[label] = locale.getText(label)));
event.sender.send(EVENT_TYPE.ABOUT.LOCALE_RENDER, resultLabels);
}
}
});
// Close window via escape
aboutWindow.webContents.on('before-input-event', (_event, input) => {
if (input.type === 'keyDown' && input.key === 'Escape') {
if (aboutWindow) {
aboutWindow.close();
}
}
});
aboutWindow.on('closed', () => (aboutWindow = undefined));
await aboutWindow.loadURL(ABOUT_HTML);
if (aboutWindow) {
aboutWindow.webContents.send(EVENT_TYPE.ABOUT.LOADED, {
copyright: config.copyright,
electronVersion: config.version,
productName: config.name,
webappVersion,
});
}
}
aboutWindow.show();
}; | CWE-20 | 0 |
from: globalDb.getServerTitle() + " <" + returnAddress + ">",
subject: "Testing your Sandstorm's SMTP setting",
text: "Success! Your outgoing SMTP is working.",
smtpConfig: restConfig,
});
} catch (e) {
// Attempt to give more accurate error messages for a variety of known failure modes,
// and the actual exception data in the event a user hits a new failure mode.
if (e.syscall === "getaddrinfo") {
if (e.code === "EIO" || e.code === "ENOTFOUND") {
throw new Meteor.Error("getaddrinfo " + e.code, "Couldn't resolve \"" + smtpConfig.hostname + "\" - check for typos or broken DNS.");
}
} else if (e.syscall === "connect") {
if (e.code === "ECONNREFUSED") {
throw new Meteor.Error("connect ECONNREFUSED", "Server at " + smtpConfig.hostname + ":" + smtpConfig.port + " refused connection. Check your settings, firewall rules, and that your mail server is up.");
}
} else if (e.name === "AuthError") {
throw new Meteor.Error("auth error", "Authentication failed. Check your credentials. Message from " +
smtpConfig.hostname + ": " + e.data);
}
throw new Meteor.Error("other-email-sending-error", "Error while trying to send test email: " + JSON.stringify(e));
}
}, | CWE-287 | 4 |
requestResetPassword(req) {
const config = req.config;
if (!config) {
this.invalidRequest();
}
if (!config.publicServerURL) {
return this.missingPublicServerURL();
}
const { username, token } = req.query;
if (!username || !token) {
return this.invalidLink(req);
}
return config.userController.checkResetTokenValidity(username, token).then(
() => {
const params = qs.stringify({
token,
id: config.applicationId,
username,
app: config.appName,
});
return Promise.resolve({
status: 302,
location: `${config.choosePasswordURL}?${params}`,
});
},
() => {
return this.invalidLink(req);
}
);
} | CWE-863 | 11 |
export function get(key: "treeIcons"): boolean;
export function get(key: "apiUrl"): string; | CWE-863 | 11 |
WebContents.prototype._sendToFrameInternal = function (frameId, channel, ...args) {
if (typeof channel !== 'string') {
throw new Error('Missing required channel argument');
} else if (typeof frameId !== 'number') {
throw new Error('Missing required frameId argument');
}
return this._sendToFrame(true /* internal */, frameId, channel, args);
}; | CWE-668 | 7 |
async function logPlatform(logger: Logger): Promise<void> {
const os = require('os');
let platform = os.platform();
logger.log(`OS is ${platform}`);
if (platform === 'darwin' || platform === 'win32') {
return;
}
const osInfo = require('linux-os-info');
const result = await osInfo();
const dist = result.id;
logger.log(`dist: ${dist}`);
} | CWE-863 | 11 |
constructor(options: PacketAssemblerOptions) {
super();
this._stack = [];
this.expectedLength = 0;
this.currentLength = 0;
this.readMessageFunc = options.readMessageFunc;
this.minimumSizeInBytes = options.minimumSizeInBytes || 8;
assert(typeof this.readMessageFunc === "function", "packet assembler requires a readMessageFunc");
} | CWE-400 | 2 |
private _on_receive_message_chunk(messageChunk: Buffer) {
/* istanbul ignore next */
if (doDebug1) {
const _stream = new BinaryStream(messageChunk);
const messageHeader = readMessageHeader(_stream);
debugLog("CLIENT RECEIVED " + chalk.yellow(JSON.stringify(messageHeader) + ""));
debugLog("\n" + hexDump(messageChunk));
debugLog(messageHeaderToString(messageChunk));
}
this.messageBuilder.feed(messageChunk);
}
| CWE-400 | 2 |
Subsets and Splits