Datasets:

ecwk

/

vulnerable-functions-and-commits_cvefixes-2022

like 1

CVE-2021-26788

False

False

False

False

AV:N/AC:L/Au:N/C:N/I:N/A:P

NETWORK

LOW

NONE

NONE

NONE

PARTIAL

5.0

CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H

NETWORK

LOW

NONE

NONE

UNCHANGED

NONE

NONE

HIGH

7.5

HIGH

3.9

3.6

False

[{'url': 'https://github.com/Oryx-Embedded/CycloneTCP/commit/de5336016edbe1e90327d0ed1cba5c4e49114366?branch=de5336016edbe1e90327d0ed1cba5c4e49114366&diff=split', 'name': 'https://github.com/Oryx-Embedded/CycloneTCP/commit/de5336016edbe1e90327d0ed1cba5c4e49114366?branch=de5336016edbe1e90327d0ed1cba5c4e49114366&diff=split', 'refsource': 'MISC', 'tags': ['Patch', 'Third Party Advisory']}]

[{'description': [{'lang': 'en', 'value': 'CWE-20'}]}]

MEDIUM

[{'operator': 'OR', 'children': [], 'cpe_match': [{'vulnerable': True, 'cpe23Uri': 'cpe:2.3:a:oryx-embedded:cyclonetcp:*:*:*:*:*:*:*:*', 'versionStartIncluding': '1.7.6', 'versionEndIncluding': '2.0.0', 'cpe_name': []}]}]

[{'lang': 'en', 'value': 'Oryx Embedded CycloneTCP 1.7.6 to 2.0.0, fixed in 2.0.2, is affected by incorrect input validation, which may cause a denial of service (DoS). To exploit the vulnerability, an attacker needs to have TCP connectivity to the target system. Receiving a maliciously crafted TCP packet from an unauthenticated endpoint is sufficient to trigger the bug.'}]

2021-03-12T21:37Z

2021-03-08T13:15Z

Improper Input Validation

The product receives input or data, but it does not validate or incorrectly validates that the input has the properties that are required to process the data safely and correctly.

Input validation is a frequently-used technique for checking potentially dangerous inputs in order to ensure that the inputs are safe for processing within the code, or when communicating with other components. When software does not validate input properly, an attacker is able to craft the input in a form that is not expected by the rest of the application. This will lead to parts of the system receiving unintended input, which may result in altered control flow, arbitrary control of a resource, or arbitrary code execution. Input validation is not the only technique for processing input, however. Other techniques attempt to transform potentially-dangerous input into something safe, such as filtering (CWE-790) - which attempts to remove dangerous inputs - or encoding/escaping (CWE-116), which attempts to ensure that the input is not misinterpreted when it is included in output to another component. Other techniques exist as well (see CWE-138 for more examples.) Input validation can be applied to: raw data - strings, numbers, parameters, file contents, etc. metadata - information about the raw data, such as headers or size Data can be simple or structured. Structured data can be composed of many nested layers, composed of combinations of metadata and raw data, with other simple or structured data. Many properties of raw data or metadata may need to be validated upon entry into the code, such as: specified quantities such as size, length, frequency, price, rate, number of operations, time, etc. implied or derived quantities, such as the actual size of a file instead of a specified size indexes, offsets, or positions into more complex data structures symbolic keys or other elements into hash tables, associative arrays, etc. well-formedness, i.e. syntactic correctness - compliance with expected syntax lexical token correctness - compliance with rules for what is treated as a token specified or derived type - the actual type of the input (or what the input appears to be) consistency - between individual data elements, between raw data and metadata, between references, etc. conformance to domain-specific rules, e.g. business logic equivalence - ensuring that equivalent inputs are treated the same authenticity, ownership, or other attestations about the input, e.g. a cryptographic signature to prove the source of the data Implied or derived properties of data must often be calculated or inferred by the code itself. Errors in deriving properties may be considered a contributing factor to improper input validation. Note that "input validation" has very different meanings to different people, or within different classification schemes. Caution must be used when referencing this CWE entry or mapping to it. For example, some weaknesses might involve inadvertently giving control to an attacker over an input when they should not be able to provide an input at all, but sometimes this is referred to as input validation. Finally, it is important to emphasize that the distinctions between input validation and output escaping are often blurred, and developers must be careful to understand the difference, including how input validation is not always sufficient to prevent vulnerabilities, especially when less stringent data types must be supported, such as free-form text. Consider a SQL injection scenario in which a person's last name is inserted into a query. The name "O'Reilly" would likely pass the validation step since it is a common last name in the English language. However, this valid name cannot be directly inserted into the database because it contains the "'" apostrophe character, which would need to be escaped or otherwise transformed. In this case, removing the apostrophe might reduce the risk of SQL injection, but it would produce incorrect behavior because the wrong name would be recorded.

https://cwe.mitre.org/data/definitions/20.html

OryxEmbeddedAdmin

2021-01-08 10:16:26+01:00

Version 2.0.2

de5336016edbe1e90327d0ed1cba5c4e49114366

False

Oryx-Embedded/CycloneTCP

Dual IPv4/IPv6 Stack

2017-01-14 13:53:42

2022-06-30 05:56:20

https://www.oryx-embedded.com/products/CycloneTCP

Oryx-Embedded

101.0

56.0

coapServerFormatReset

coapServerFormatReset( CoapServerContext * context , uint16_t mid)

['context', 'mid']

error_t coapServerFormatReset(CoapServerContext *context, uint16_t mid) { CoapMessageHeader *header; //Point to the CoAP response header header = (CoapMessageHeader *) context->response.buffer; //Format Reset message header->version = COAP_VERSION_1; header->type = COAP_TYPE_RST; header->tokenLen = 0; header->code = COAP_CODE_EMPTY; //The Reset message message must echo the message ID of the confirmable //message and must be empty (refer to RFC 7252, section 4.2) header->mid = htons(mid); //Set the length of the CoAP message context->response.length = sizeof(CoapMessageHeader); //Sucessful processing return NO_ERROR; }

74

True

CVE-2021-26788

False

False

False

False

AV:N/AC:L/Au:N/C:N/I:N/A:P

NETWORK

LOW

NONE

NONE

NONE

PARTIAL

5.0

CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H

NETWORK

LOW

NONE

NONE

UNCHANGED

NONE

NONE

HIGH

7.5

HIGH

3.9

3.6

False

[{'url': 'https://github.com/Oryx-Embedded/CycloneTCP/commit/de5336016edbe1e90327d0ed1cba5c4e49114366?branch=de5336016edbe1e90327d0ed1cba5c4e49114366&diff=split', 'name': 'https://github.com/Oryx-Embedded/CycloneTCP/commit/de5336016edbe1e90327d0ed1cba5c4e49114366?branch=de5336016edbe1e90327d0ed1cba5c4e49114366&diff=split', 'refsource': 'MISC', 'tags': ['Patch', 'Third Party Advisory']}]

[{'description': [{'lang': 'en', 'value': 'CWE-20'}]}]

MEDIUM

[{'operator': 'OR', 'children': [], 'cpe_match': [{'vulnerable': True, 'cpe23Uri': 'cpe:2.3:a:oryx-embedded:cyclonetcp:*:*:*:*:*:*:*:*', 'versionStartIncluding': '1.7.6', 'versionEndIncluding': '2.0.0', 'cpe_name': []}]}]

[{'lang': 'en', 'value': 'Oryx Embedded CycloneTCP 1.7.6 to 2.0.0, fixed in 2.0.2, is affected by incorrect input validation, which may cause a denial of service (DoS). To exploit the vulnerability, an attacker needs to have TCP connectivity to the target system. Receiving a maliciously crafted TCP packet from an unauthenticated endpoint is sufficient to trigger the bug.'}]

2021-03-12T21:37Z

2021-03-08T13:15Z

Improper Input Validation

The product receives input or data, but it does not validate or incorrectly validates that the input has the properties that are required to process the data safely and correctly.

Input validation is a frequently-used technique for checking potentially dangerous inputs in order to ensure that the inputs are safe for processing within the code, or when communicating with other components. When software does not validate input properly, an attacker is able to craft the input in a form that is not expected by the rest of the application. This will lead to parts of the system receiving unintended input, which may result in altered control flow, arbitrary control of a resource, or arbitrary code execution. Input validation is not the only technique for processing input, however. Other techniques attempt to transform potentially-dangerous input into something safe, such as filtering (CWE-790) - which attempts to remove dangerous inputs - or encoding/escaping (CWE-116), which attempts to ensure that the input is not misinterpreted when it is included in output to another component. Other techniques exist as well (see CWE-138 for more examples.) Input validation can be applied to: raw data - strings, numbers, parameters, file contents, etc. metadata - information about the raw data, such as headers or size Data can be simple or structured. Structured data can be composed of many nested layers, composed of combinations of metadata and raw data, with other simple or structured data. Many properties of raw data or metadata may need to be validated upon entry into the code, such as: specified quantities such as size, length, frequency, price, rate, number of operations, time, etc. implied or derived quantities, such as the actual size of a file instead of a specified size indexes, offsets, or positions into more complex data structures symbolic keys or other elements into hash tables, associative arrays, etc. well-formedness, i.e. syntactic correctness - compliance with expected syntax lexical token correctness - compliance with rules for what is treated as a token specified or derived type - the actual type of the input (or what the input appears to be) consistency - between individual data elements, between raw data and metadata, between references, etc. conformance to domain-specific rules, e.g. business logic equivalence - ensuring that equivalent inputs are treated the same authenticity, ownership, or other attestations about the input, e.g. a cryptographic signature to prove the source of the data Implied or derived properties of data must often be calculated or inferred by the code itself. Errors in deriving properties may be considered a contributing factor to improper input validation. Note that "input validation" has very different meanings to different people, or within different classification schemes. Caution must be used when referencing this CWE entry or mapping to it. For example, some weaknesses might involve inadvertently giving control to an attacker over an input when they should not be able to provide an input at all, but sometimes this is referred to as input validation. Finally, it is important to emphasize that the distinctions between input validation and output escaping are often blurred, and developers must be careful to understand the difference, including how input validation is not always sufficient to prevent vulnerabilities, especially when less stringent data types must be supported, such as free-form text. Consider a SQL injection scenario in which a person's last name is inserted into a query. The name "O'Reilly" would likely pass the validation step since it is a common last name in the English language. However, this valid name cannot be directly inserted into the database because it contains the "'" apostrophe character, which would need to be escaped or otherwise transformed. In this case, removing the apostrophe might reduce the risk of SQL injection, but it would produce incorrect behavior because the wrong name would be recorded.

https://cwe.mitre.org/data/definitions/20.html

OryxEmbeddedAdmin

2021-01-08 10:16:26+01:00

Version 2.0.2

de5336016edbe1e90327d0ed1cba5c4e49114366

False

Oryx-Embedded/CycloneTCP

Dual IPv4/IPv6 Stack

2017-01-14 13:53:42

2022-06-30 05:56:20

https://www.oryx-embedded.com/products/CycloneTCP

Oryx-Embedded

101.0

56.0

coapServerInitResponse

coapServerInitResponse( CoapServerContext * context)

['context']

error_t coapServerInitResponse(CoapServerContext *context) { CoapMessageHeader *requestHeader; CoapMessageHeader *responseHeader; //Point to the CoAP request header requestHeader = (CoapMessageHeader *) context->request.buffer; //Point to the CoAP response header responseHeader = (CoapMessageHeader *) context->response.buffer; //Format message header responseHeader->version = COAP_VERSION_1; responseHeader->tokenLen = requestHeader->tokenLen; responseHeader->code = COAP_CODE_INTERNAL_SERVER; responseHeader->mid = requestHeader->mid; //If immediately available, the response to a request carried in a //Confirmable message is carried in an Acknowledgement (ACK) message if(requestHeader->type == COAP_TYPE_CON) { responseHeader->type = COAP_TYPE_ACK; } else { responseHeader->type = COAP_TYPE_NON; } //The token is used to match a response with a request osMemcpy(responseHeader->token, requestHeader->token, requestHeader->tokenLen); //Set the length of the CoAP message context->response.length = sizeof(CoapMessageHeader) + responseHeader->tokenLen; context->response.pos = 0; //Sucessful processing return NO_ERROR; }

134

True

CVE-2021-26788

False

False

False

False

AV:N/AC:L/Au:N/C:N/I:N/A:P

NETWORK

LOW

NONE

NONE

NONE

PARTIAL

5.0

CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H

NETWORK

LOW

NONE

NONE

UNCHANGED

NONE

NONE

HIGH

7.5

HIGH

3.9

3.6

False

[{'url': 'https://github.com/Oryx-Embedded/CycloneTCP/commit/de5336016edbe1e90327d0ed1cba5c4e49114366?branch=de5336016edbe1e90327d0ed1cba5c4e49114366&diff=split', 'name': 'https://github.com/Oryx-Embedded/CycloneTCP/commit/de5336016edbe1e90327d0ed1cba5c4e49114366?branch=de5336016edbe1e90327d0ed1cba5c4e49114366&diff=split', 'refsource': 'MISC', 'tags': ['Patch', 'Third Party Advisory']}]

[{'description': [{'lang': 'en', 'value': 'CWE-20'}]}]

MEDIUM

[{'operator': 'OR', 'children': [], 'cpe_match': [{'vulnerable': True, 'cpe23Uri': 'cpe:2.3:a:oryx-embedded:cyclonetcp:*:*:*:*:*:*:*:*', 'versionStartIncluding': '1.7.6', 'versionEndIncluding': '2.0.0', 'cpe_name': []}]}]

[{'lang': 'en', 'value': 'Oryx Embedded CycloneTCP 1.7.6 to 2.0.0, fixed in 2.0.2, is affected by incorrect input validation, which may cause a denial of service (DoS). To exploit the vulnerability, an attacker needs to have TCP connectivity to the target system. Receiving a maliciously crafted TCP packet from an unauthenticated endpoint is sufficient to trigger the bug.'}]

2021-03-12T21:37Z

2021-03-08T13:15Z

Improper Input Validation

The product receives input or data, but it does not validate or incorrectly validates that the input has the properties that are required to process the data safely and correctly.

Input validation is a frequently-used technique for checking potentially dangerous inputs in order to ensure that the inputs are safe for processing within the code, or when communicating with other components. When software does not validate input properly, an attacker is able to craft the input in a form that is not expected by the rest of the application. This will lead to parts of the system receiving unintended input, which may result in altered control flow, arbitrary control of a resource, or arbitrary code execution. Input validation is not the only technique for processing input, however. Other techniques attempt to transform potentially-dangerous input into something safe, such as filtering (CWE-790) - which attempts to remove dangerous inputs - or encoding/escaping (CWE-116), which attempts to ensure that the input is not misinterpreted when it is included in output to another component. Other techniques exist as well (see CWE-138 for more examples.) Input validation can be applied to: raw data - strings, numbers, parameters, file contents, etc. metadata - information about the raw data, such as headers or size Data can be simple or structured. Structured data can be composed of many nested layers, composed of combinations of metadata and raw data, with other simple or structured data. Many properties of raw data or metadata may need to be validated upon entry into the code, such as: specified quantities such as size, length, frequency, price, rate, number of operations, time, etc. implied or derived quantities, such as the actual size of a file instead of a specified size indexes, offsets, or positions into more complex data structures symbolic keys or other elements into hash tables, associative arrays, etc. well-formedness, i.e. syntactic correctness - compliance with expected syntax lexical token correctness - compliance with rules for what is treated as a token specified or derived type - the actual type of the input (or what the input appears to be) consistency - between individual data elements, between raw data and metadata, between references, etc. conformance to domain-specific rules, e.g. business logic equivalence - ensuring that equivalent inputs are treated the same authenticity, ownership, or other attestations about the input, e.g. a cryptographic signature to prove the source of the data Implied or derived properties of data must often be calculated or inferred by the code itself. Errors in deriving properties may be considered a contributing factor to improper input validation. Note that "input validation" has very different meanings to different people, or within different classification schemes. Caution must be used when referencing this CWE entry or mapping to it. For example, some weaknesses might involve inadvertently giving control to an attacker over an input when they should not be able to provide an input at all, but sometimes this is referred to as input validation. Finally, it is important to emphasize that the distinctions between input validation and output escaping are often blurred, and developers must be careful to understand the difference, including how input validation is not always sufficient to prevent vulnerabilities, especially when less stringent data types must be supported, such as free-form text. Consider a SQL injection scenario in which a person's last name is inserted into a query. The name "O'Reilly" would likely pass the validation step since it is a common last name in the English language. However, this valid name cannot be directly inserted into the database because it contains the "'" apostrophe character, which would need to be escaped or otherwise transformed. In this case, removing the apostrophe might reduce the risk of SQL injection, but it would produce incorrect behavior because the wrong name would be recorded.

https://cwe.mitre.org/data/definitions/20.html

OryxEmbeddedAdmin

2021-01-08 10:16:26+01:00

Version 2.0.2

de5336016edbe1e90327d0ed1cba5c4e49114366

False

Oryx-Embedded/CycloneTCP

Dual IPv4/IPv6 Stack

2017-01-14 13:53:42

2022-06-30 05:56:20

https://www.oryx-embedded.com/products/CycloneTCP

Oryx-Embedded

101.0

56.0

ipStringToAddr

ipStringToAddr( const char_t * str , IpAddr * ipAddr)

['str', 'ipAddr']

error_t ipStringToAddr(const char_t *str, IpAddr *ipAddr) { error_t error; #if (IPV6_SUPPORT == ENABLED) //IPv6 address? if(strchr(str, ':')) { //IPv6 addresses are 16-byte long ipAddr->length = sizeof(Ipv6Addr); //Convert the string to IPv6 address error = ipv6StringToAddr(str, &ipAddr->ipv6Addr); } else #endif #if (IPV4_SUPPORT == ENABLED) //IPv4 address? if(strchr(str, '.')) { //IPv4 addresses are 4-byte long ipAddr->length = sizeof(Ipv4Addr); //Convert the string to IPv4 address error = ipv4StringToAddr(str, &ipAddr->ipv4Addr); } else #endif //Invalid IP address? { //Report an error error = ERROR_FAILURE; } //Return status code return error; }

91

True

CVE-2021-26788

False

False

False

False

AV:N/AC:L/Au:N/C:N/I:N/A:P

NETWORK

LOW

NONE

NONE

NONE

PARTIAL

5.0

CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H

NETWORK

LOW

NONE

NONE

UNCHANGED

NONE

NONE

HIGH

7.5

HIGH

3.9

3.6

False

[{'url': 'https://github.com/Oryx-Embedded/CycloneTCP/commit/de5336016edbe1e90327d0ed1cba5c4e49114366?branch=de5336016edbe1e90327d0ed1cba5c4e49114366&diff=split', 'name': 'https://github.com/Oryx-Embedded/CycloneTCP/commit/de5336016edbe1e90327d0ed1cba5c4e49114366?branch=de5336016edbe1e90327d0ed1cba5c4e49114366&diff=split', 'refsource': 'MISC', 'tags': ['Patch', 'Third Party Advisory']}]

[{'description': [{'lang': 'en', 'value': 'CWE-20'}]}]

MEDIUM

[{'operator': 'OR', 'children': [], 'cpe_match': [{'vulnerable': True, 'cpe23Uri': 'cpe:2.3:a:oryx-embedded:cyclonetcp:*:*:*:*:*:*:*:*', 'versionStartIncluding': '1.7.6', 'versionEndIncluding': '2.0.0', 'cpe_name': []}]}]

[{'lang': 'en', 'value': 'Oryx Embedded CycloneTCP 1.7.6 to 2.0.0, fixed in 2.0.2, is affected by incorrect input validation, which may cause a denial of service (DoS). To exploit the vulnerability, an attacker needs to have TCP connectivity to the target system. Receiving a maliciously crafted TCP packet from an unauthenticated endpoint is sufficient to trigger the bug.'}]

2021-03-12T21:37Z

2021-03-08T13:15Z

Improper Input Validation

The product receives input or data, but it does not validate or incorrectly validates that the input has the properties that are required to process the data safely and correctly.

Input validation is a frequently-used technique for checking potentially dangerous inputs in order to ensure that the inputs are safe for processing within the code, or when communicating with other components. When software does not validate input properly, an attacker is able to craft the input in a form that is not expected by the rest of the application. This will lead to parts of the system receiving unintended input, which may result in altered control flow, arbitrary control of a resource, or arbitrary code execution. Input validation is not the only technique for processing input, however. Other techniques attempt to transform potentially-dangerous input into something safe, such as filtering (CWE-790) - which attempts to remove dangerous inputs - or encoding/escaping (CWE-116), which attempts to ensure that the input is not misinterpreted when it is included in output to another component. Other techniques exist as well (see CWE-138 for more examples.) Input validation can be applied to: raw data - strings, numbers, parameters, file contents, etc. metadata - information about the raw data, such as headers or size Data can be simple or structured. Structured data can be composed of many nested layers, composed of combinations of metadata and raw data, with other simple or structured data. Many properties of raw data or metadata may need to be validated upon entry into the code, such as: specified quantities such as size, length, frequency, price, rate, number of operations, time, etc. implied or derived quantities, such as the actual size of a file instead of a specified size indexes, offsets, or positions into more complex data structures symbolic keys or other elements into hash tables, associative arrays, etc. well-formedness, i.e. syntactic correctness - compliance with expected syntax lexical token correctness - compliance with rules for what is treated as a token specified or derived type - the actual type of the input (or what the input appears to be) consistency - between individual data elements, between raw data and metadata, between references, etc. conformance to domain-specific rules, e.g. business logic equivalence - ensuring that equivalent inputs are treated the same authenticity, ownership, or other attestations about the input, e.g. a cryptographic signature to prove the source of the data Implied or derived properties of data must often be calculated or inferred by the code itself. Errors in deriving properties may be considered a contributing factor to improper input validation. Note that "input validation" has very different meanings to different people, or within different classification schemes. Caution must be used when referencing this CWE entry or mapping to it. For example, some weaknesses might involve inadvertently giving control to an attacker over an input when they should not be able to provide an input at all, but sometimes this is referred to as input validation. Finally, it is important to emphasize that the distinctions between input validation and output escaping are often blurred, and developers must be careful to understand the difference, including how input validation is not always sufficient to prevent vulnerabilities, especially when less stringent data types must be supported, such as free-form text. Consider a SQL injection scenario in which a person's last name is inserted into a query. The name "O'Reilly" would likely pass the validation step since it is a common last name in the English language. However, this valid name cannot be directly inserted into the database because it contains the "'" apostrophe character, which would need to be escaped or otherwise transformed. In this case, removing the apostrophe might reduce the risk of SQL injection, but it would produce incorrect behavior because the wrong name would be recorded.

https://cwe.mitre.org/data/definitions/20.html

OryxEmbeddedAdmin

2021-01-08 10:16:26+01:00

Version 2.0.2

de5336016edbe1e90327d0ed1cba5c4e49114366

False

Oryx-Embedded/CycloneTCP

Dual IPv4/IPv6 Stack

2017-01-14 13:53:42

2022-06-30 05:56:20

https://www.oryx-embedded.com/products/CycloneTCP

Oryx-Embedded

101.0

56.0

rawSocketSendEthPacket

rawSocketSendEthPacket( Socket * socket , const SocketMsg * message , uint_t flags)

['socket', 'message', 'flags']

error_t rawSocketSendEthPacket(Socket *socket, const SocketMsg *message, uint_t flags) { error_t error; #if (ETH_SUPPORT == ENABLED) size_t length; NetBuffer *buffer; NetInterface *interface; //Select the relevant network interface if(socket->interface != NULL) { interface = socket->interface; } else { interface = netGetDefaultInterface(); } //Forward the frame to the physical interface interface = nicGetPhysicalInterface(interface); //Ethernet interface? if(interface->nicDriver != NULL && interface->nicDriver->type == NIC_TYPE_ETHERNET) { //Allocate a buffer memory to hold the raw Ethernet packet buffer = netBufferAlloc(0); //Failed to allocate buffer? if(buffer == NULL) return ERROR_OUT_OF_MEMORY; //Get the length of the raw data length = message->length; //Copy the raw data error = netBufferAppend(buffer, message->data, length); //Check status code if(!error) { //Automatic padding not supported by hardware? if(!interface->nicDriver->autoPadding) { //The host controller should manually add padding //to the packet before transmitting it if(length < (ETH_MIN_FRAME_SIZE - ETH_CRC_SIZE)) { size_t n; //Add padding as necessary n = (ETH_MIN_FRAME_SIZE - ETH_CRC_SIZE) - length; //Append padding bytes error = netBufferAppend(buffer, ethPadding, n); //Adjust frame length length += n; } } } //Check status code if(!error) { //CRC calculation not supported by hardware? if(!interface->nicDriver->autoCrcCalc) { uint32_t crc; //Compute CRC over the header and payload crc = ethCalcCrcEx(buffer, 0, length); //Convert from host byte order to little-endian byte order crc = htole32(crc); //Append the calculated CRC value error = netBufferAppend(buffer, &crc, sizeof(crc)); //Adjust frame length length += sizeof(crc); } } //Check status code if(!error) { NetTxAncillary ancillary; //Additional options can be passed to the stack along with the packet ancillary = NET_DEFAULT_TX_ANCILLARY; #if (ETH_PORT_TAGGING_SUPPORT == ENABLED) //Set switch port identifier ancillary.port = message->switchPort; #endif #if (ETH_TIMESTAMP_SUPPORT == ENABLED) //Unique identifier for hardware time stamping ancillary.timestampId = message->timestampId; #endif //Debug message TRACE_DEBUG("Sending raw Ethernet frame (%" PRIuSIZE " bytes)...\r\n", length); //Send the resulting packet over the specified link error = nicSendPacket(interface, buffer, 0, &ancillary); } //Free previously allocated memory block netBufferFree(buffer); } else #endif //Unknown interface type? { //Report an error error = ERROR_INVALID_INTERFACE; } //Return status code return error; }

302

True

CVE-2021-26788

False

False

False

False

AV:N/AC:L/Au:N/C:N/I:N/A:P

NETWORK

LOW

NONE

NONE

NONE

PARTIAL

5.0

CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H

NETWORK

LOW

NONE

NONE

UNCHANGED

NONE

NONE

HIGH

7.5

HIGH

3.9

3.6

False

[{'url': 'https://github.com/Oryx-Embedded/CycloneTCP/commit/de5336016edbe1e90327d0ed1cba5c4e49114366?branch=de5336016edbe1e90327d0ed1cba5c4e49114366&diff=split', 'name': 'https://github.com/Oryx-Embedded/CycloneTCP/commit/de5336016edbe1e90327d0ed1cba5c4e49114366?branch=de5336016edbe1e90327d0ed1cba5c4e49114366&diff=split', 'refsource': 'MISC', 'tags': ['Patch', 'Third Party Advisory']}]

[{'description': [{'lang': 'en', 'value': 'CWE-20'}]}]

MEDIUM

[{'operator': 'OR', 'children': [], 'cpe_match': [{'vulnerable': True, 'cpe23Uri': 'cpe:2.3:a:oryx-embedded:cyclonetcp:*:*:*:*:*:*:*:*', 'versionStartIncluding': '1.7.6', 'versionEndIncluding': '2.0.0', 'cpe_name': []}]}]

[{'lang': 'en', 'value': 'Oryx Embedded CycloneTCP 1.7.6 to 2.0.0, fixed in 2.0.2, is affected by incorrect input validation, which may cause a denial of service (DoS). To exploit the vulnerability, an attacker needs to have TCP connectivity to the target system. Receiving a maliciously crafted TCP packet from an unauthenticated endpoint is sufficient to trigger the bug.'}]

2021-03-12T21:37Z

2021-03-08T13:15Z

Improper Input Validation

The product receives input or data, but it does not validate or incorrectly validates that the input has the properties that are required to process the data safely and correctly.

Input validation is a frequently-used technique for checking potentially dangerous inputs in order to ensure that the inputs are safe for processing within the code, or when communicating with other components. When software does not validate input properly, an attacker is able to craft the input in a form that is not expected by the rest of the application. This will lead to parts of the system receiving unintended input, which may result in altered control flow, arbitrary control of a resource, or arbitrary code execution. Input validation is not the only technique for processing input, however. Other techniques attempt to transform potentially-dangerous input into something safe, such as filtering (CWE-790) - which attempts to remove dangerous inputs - or encoding/escaping (CWE-116), which attempts to ensure that the input is not misinterpreted when it is included in output to another component. Other techniques exist as well (see CWE-138 for more examples.) Input validation can be applied to: raw data - strings, numbers, parameters, file contents, etc. metadata - information about the raw data, such as headers or size Data can be simple or structured. Structured data can be composed of many nested layers, composed of combinations of metadata and raw data, with other simple or structured data. Many properties of raw data or metadata may need to be validated upon entry into the code, such as: specified quantities such as size, length, frequency, price, rate, number of operations, time, etc. implied or derived quantities, such as the actual size of a file instead of a specified size indexes, offsets, or positions into more complex data structures symbolic keys or other elements into hash tables, associative arrays, etc. well-formedness, i.e. syntactic correctness - compliance with expected syntax lexical token correctness - compliance with rules for what is treated as a token specified or derived type - the actual type of the input (or what the input appears to be) consistency - between individual data elements, between raw data and metadata, between references, etc. conformance to domain-specific rules, e.g. business logic equivalence - ensuring that equivalent inputs are treated the same authenticity, ownership, or other attestations about the input, e.g. a cryptographic signature to prove the source of the data Implied or derived properties of data must often be calculated or inferred by the code itself. Errors in deriving properties may be considered a contributing factor to improper input validation. Note that "input validation" has very different meanings to different people, or within different classification schemes. Caution must be used when referencing this CWE entry or mapping to it. For example, some weaknesses might involve inadvertently giving control to an attacker over an input when they should not be able to provide an input at all, but sometimes this is referred to as input validation. Finally, it is important to emphasize that the distinctions between input validation and output escaping are often blurred, and developers must be careful to understand the difference, including how input validation is not always sufficient to prevent vulnerabilities, especially when less stringent data types must be supported, such as free-form text. Consider a SQL injection scenario in which a person's last name is inserted into a query. The name "O'Reilly" would likely pass the validation step since it is a common last name in the English language. However, this valid name cannot be directly inserted into the database because it contains the "'" apostrophe character, which would need to be escaped or otherwise transformed. In this case, removing the apostrophe might reduce the risk of SQL injection, but it would produce incorrect behavior because the wrong name would be recorded.

https://cwe.mitre.org/data/definitions/20.html

OryxEmbeddedAdmin

2021-01-08 10:16:26+01:00

Version 2.0.2

de5336016edbe1e90327d0ed1cba5c4e49114366

False

Oryx-Embedded/CycloneTCP

Dual IPv4/IPv6 Stack

2017-01-14 13:53:42

2022-06-30 05:56:20

https://www.oryx-embedded.com/products/CycloneTCP

Oryx-Embedded

101.0

56.0

rawSocketSendIpPacket

rawSocketSendIpPacket( Socket * socket , const SocketMsg * message , uint_t flags)

['socket', 'message', 'flags']

error_t rawSocketSendIpPacket(Socket *socket, const SocketMsg *message, uint_t flags) { error_t error; size_t offset; NetBuffer *buffer; NetInterface *interface; IpPseudoHeader pseudoHeader; NetTxAncillary ancillary; //The socket may be bound to a particular network interface interface = socket->interface; //Allocate a buffer memory to hold the raw IP datagram buffer = ipAllocBuffer(0, &offset); //Failed to allocate memory? if(buffer == NULL) return ERROR_OUT_OF_MEMORY; //Start of exception handling block do { //Copy the raw data error = netBufferAppend(buffer, message->data, message->length); //Any error to report? if(error) break; #if (IPV4_SUPPORT == ENABLED) //Destination address is an IPv4 address? if(message->destIpAddr.length == sizeof(Ipv4Addr)) { Ipv4Addr srcIpAddr; //Select the source IPv4 address and the relevant network interface //to use when sending data to the specified destination host error = ipv4SelectSourceAddr(&interface, message->destIpAddr.ipv4Addr, &srcIpAddr); //Any error to report? if(error) break; //Format IPv4 pseudo header pseudoHeader.length = sizeof(Ipv4PseudoHeader); pseudoHeader.ipv4Data.srcAddr = srcIpAddr; pseudoHeader.ipv4Data.destAddr = message->destIpAddr.ipv4Addr; pseudoHeader.ipv4Data.reserved = 0; pseudoHeader.ipv4Data.protocol = socket->protocol; pseudoHeader.ipv4Data.length = htons(message->length); } else #endif #if (IPV6_SUPPORT == ENABLED) //Destination address is an IPv6 address? if(message->destIpAddr.length == sizeof(Ipv6Addr)) { //Select the source IPv6 address and the relevant network interface //to use when sending data to the specified destination host error = ipv6SelectSourceAddr(&interface, &message->destIpAddr.ipv6Addr, &pseudoHeader.ipv6Data.srcAddr); //Any error to report? if(error) break; //Format IPv6 pseudo header pseudoHeader.length = sizeof(Ipv6PseudoHeader); pseudoHeader.ipv6Data.destAddr = message->destIpAddr.ipv6Addr; pseudoHeader.ipv6Data.length = htonl(message->length); pseudoHeader.ipv6Data.reserved[0] = 0; pseudoHeader.ipv6Data.reserved[1] = 0; pseudoHeader.ipv6Data.reserved[2] = 0; pseudoHeader.ipv6Data.nextHeader = socket->protocol; } else #endif //Invalid destination address? { //An internal error has occurred error = ERROR_FAILURE; //Exit immediately break; } //Additional options can be passed to the stack along with the packet ancillary = NET_DEFAULT_TX_ANCILLARY; //Set the TTL value to be used if(message->ttl != 0) { ancillary.ttl = message->ttl; } else if(ipIsMulticastAddr(&message->destIpAddr)) { ancillary.ttl = socket->multicastTtl; } else { ancillary.ttl = socket->ttl; } //This flag tells the stack that the destination is on a locally attached //network and not to perform a lookup of the routing table if(flags & SOCKET_FLAG_DONT_ROUTE) { ancillary.dontRoute = TRUE; } #if (IP_DIFF_SERV_SUPPORT == ENABLED) //Set DSCP field ancillary.dscp = socket->dscp; #endif #if (ETH_SUPPORT == ENABLED) //Set source and destination MAC addresses ancillary.srcMacAddr = message->srcMacAddr; ancillary.destMacAddr = message->destMacAddr; #endif #if (ETH_VLAN_SUPPORT == ENABLED) //Set VLAN PCP and DEI fields ancillary.vlanPcp = socket->vlanPcp; ancillary.vlanDei = socket->vlanDei; #endif #if (ETH_VMAN_SUPPORT == ENABLED) //Set VMAN PCP and DEI fields ancillary.vmanPcp = socket->vmanPcp; ancillary.vmanDei = socket->vmanDei; #endif #if (ETH_PORT_TAGGING_SUPPORT == ENABLED) //Set switch port identifier ancillary.port = message->switchPort; #endif #if (ETH_TIMESTAMP_SUPPORT == ENABLED) //Unique identifier for hardware time stamping ancillary.timestampId = message->timestampId; #endif //Send raw IP datagram error = ipSendDatagram(interface, &pseudoHeader, buffer, offset, &ancillary); //Failed to send data? if(error) break; //End of exception handling block } while(0); //Free previously allocated memory block netBufferFree(buffer); //Return status code return error; }

492

True

CVE-2021-26788

False

False

False

False

AV:N/AC:L/Au:N/C:N/I:N/A:P

NETWORK

LOW

NONE

NONE

NONE

PARTIAL

5.0

CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H

NETWORK

LOW

NONE

NONE

UNCHANGED

NONE

NONE

HIGH

7.5

HIGH

3.9

3.6

False

[{'url': 'https://github.com/Oryx-Embedded/CycloneTCP/commit/de5336016edbe1e90327d0ed1cba5c4e49114366?branch=de5336016edbe1e90327d0ed1cba5c4e49114366&diff=split', 'name': 'https://github.com/Oryx-Embedded/CycloneTCP/commit/de5336016edbe1e90327d0ed1cba5c4e49114366?branch=de5336016edbe1e90327d0ed1cba5c4e49114366&diff=split', 'refsource': 'MISC', 'tags': ['Patch', 'Third Party Advisory']}]

[{'description': [{'lang': 'en', 'value': 'CWE-20'}]}]

MEDIUM

[{'operator': 'OR', 'children': [], 'cpe_match': [{'vulnerable': True, 'cpe23Uri': 'cpe:2.3:a:oryx-embedded:cyclonetcp:*:*:*:*:*:*:*:*', 'versionStartIncluding': '1.7.6', 'versionEndIncluding': '2.0.0', 'cpe_name': []}]}]

[{'lang': 'en', 'value': 'Oryx Embedded CycloneTCP 1.7.6 to 2.0.0, fixed in 2.0.2, is affected by incorrect input validation, which may cause a denial of service (DoS). To exploit the vulnerability, an attacker needs to have TCP connectivity to the target system. Receiving a maliciously crafted TCP packet from an unauthenticated endpoint is sufficient to trigger the bug.'}]

2021-03-12T21:37Z

2021-03-08T13:15Z

Improper Input Validation

The product receives input or data, but it does not validate or incorrectly validates that the input has the properties that are required to process the data safely and correctly.

Input validation is a frequently-used technique for checking potentially dangerous inputs in order to ensure that the inputs are safe for processing within the code, or when communicating with other components. When software does not validate input properly, an attacker is able to craft the input in a form that is not expected by the rest of the application. This will lead to parts of the system receiving unintended input, which may result in altered control flow, arbitrary control of a resource, or arbitrary code execution. Input validation is not the only technique for processing input, however. Other techniques attempt to transform potentially-dangerous input into something safe, such as filtering (CWE-790) - which attempts to remove dangerous inputs - or encoding/escaping (CWE-116), which attempts to ensure that the input is not misinterpreted when it is included in output to another component. Other techniques exist as well (see CWE-138 for more examples.) Input validation can be applied to: raw data - strings, numbers, parameters, file contents, etc. metadata - information about the raw data, such as headers or size Data can be simple or structured. Structured data can be composed of many nested layers, composed of combinations of metadata and raw data, with other simple or structured data. Many properties of raw data or metadata may need to be validated upon entry into the code, such as: specified quantities such as size, length, frequency, price, rate, number of operations, time, etc. implied or derived quantities, such as the actual size of a file instead of a specified size indexes, offsets, or positions into more complex data structures symbolic keys or other elements into hash tables, associative arrays, etc. well-formedness, i.e. syntactic correctness - compliance with expected syntax lexical token correctness - compliance with rules for what is treated as a token specified or derived type - the actual type of the input (or what the input appears to be) consistency - between individual data elements, between raw data and metadata, between references, etc. conformance to domain-specific rules, e.g. business logic equivalence - ensuring that equivalent inputs are treated the same authenticity, ownership, or other attestations about the input, e.g. a cryptographic signature to prove the source of the data Implied or derived properties of data must often be calculated or inferred by the code itself. Errors in deriving properties may be considered a contributing factor to improper input validation. Note that "input validation" has very different meanings to different people, or within different classification schemes. Caution must be used when referencing this CWE entry or mapping to it. For example, some weaknesses might involve inadvertently giving control to an attacker over an input when they should not be able to provide an input at all, but sometimes this is referred to as input validation. Finally, it is important to emphasize that the distinctions between input validation and output escaping are often blurred, and developers must be careful to understand the difference, including how input validation is not always sufficient to prevent vulnerabilities, especially when less stringent data types must be supported, such as free-form text. Consider a SQL injection scenario in which a person's last name is inserted into a query. The name "O'Reilly" would likely pass the validation step since it is a common last name in the English language. However, this valid name cannot be directly inserted into the database because it contains the "'" apostrophe character, which would need to be escaped or otherwise transformed. In this case, removing the apostrophe might reduce the risk of SQL injection, but it would produce incorrect behavior because the wrong name would be recorded.

https://cwe.mitre.org/data/definitions/20.html

OryxEmbeddedAdmin

2021-01-08 10:16:26+01:00

Version 2.0.2

de5336016edbe1e90327d0ed1cba5c4e49114366

False

Oryx-Embedded/CycloneTCP

Dual IPv4/IPv6 Stack

2017-01-14 13:53:42

2022-06-30 05:56:20

https://www.oryx-embedded.com/products/CycloneTCP

Oryx-Embedded

101.0

56.0

getHostByName

getHostByName( NetInterface * interface , const char_t * name , IpAddr * ipAddr , uint_t flags)

['interface', 'name', 'ipAddr', 'flags']

error_t getHostByName(NetInterface *interface, const char_t *name, IpAddr *ipAddr, uint_t flags) { error_t error; HostType type; HostnameResolver protocol; //Default address type depends on TCP/IP stack configuration #if (IPV4_SUPPORT == ENABLED) type = HOST_TYPE_IPV4; #elif (IPV6_SUPPORT == ENABLED) type = HOST_TYPE_IPV6; #else type = HOST_TYPE_ANY; #endif //Default name resolution protocol depends on TCP/IP stack configuration #if (DNS_CLIENT_SUPPORT == ENABLED) protocol = HOST_NAME_RESOLVER_DNS; #elif (MDNS_CLIENT_SUPPORT == ENABLED) protocol = HOST_NAME_RESOLVER_MDNS; #elif (NBNS_CLIENT_SUPPORT == ENABLED) protocol = HOST_NAME_RESOLVER_NBNS; #elif (LLMNR_CLIENT_SUPPORT == ENABLED) protocol = HOST_NAME_RESOLVER_LLMNR; #else protocol = HOST_NAME_RESOLVER_ANY; #endif //Check parameters if(name == NULL || ipAddr == NULL) return ERROR_INVALID_PARAMETER; //Use default network interface? if(interface == NULL) interface = netGetDefaultInterface(); //The specified name can be either an IP or a host name error = ipStringToAddr(name, ipAddr); //Perform name resolution if necessary if(error) { //The user may provide a hint to choose between IPv4 and IPv6 if(flags & HOST_TYPE_IPV4) type = HOST_TYPE_IPV4; else if(flags & HOST_TYPE_IPV6) type = HOST_TYPE_IPV6; //The user may provide a hint to to select the desired protocol to be used if(flags & HOST_NAME_RESOLVER_DNS) { //Use DNS to resolve the specified host name protocol = HOST_NAME_RESOLVER_DNS; } else if(flags & HOST_NAME_RESOLVER_MDNS) { //Use mDNS to resolve the specified host name protocol = HOST_NAME_RESOLVER_MDNS; } else if(flags & HOST_NAME_RESOLVER_NBNS) { //Use NBNS to resolve the specified host name protocol = HOST_NAME_RESOLVER_NBNS; } else if(flags & HOST_NAME_RESOLVER_LLMNR) { //Use LLMNR to resolve the specified host name protocol = HOST_NAME_RESOLVER_LLMNR; } else { //Retrieve the length of the host name to be resolved size_t n = osStrlen(name); //Select the most suitable protocol if(n >= 6 && !osStrcasecmp(name + n - 6, ".local")) { #if (MDNS_CLIENT_SUPPORT == ENABLED) //Use mDNS to resolve the specified host name protocol = HOST_NAME_RESOLVER_MDNS; #endif } else if(n <= 15 && !strchr(name, '.') && type == HOST_TYPE_IPV4) { #if (NBNS_CLIENT_SUPPORT == ENABLED) //Use NetBIOS Name Service to resolve the specified host name protocol = HOST_NAME_RESOLVER_NBNS; #endif } else if(!strchr(name, '.')) { #if (LLMNR_CLIENT_SUPPORT == ENABLED) //Use LLMNR to resolve the specified host name protocol = HOST_NAME_RESOLVER_LLMNR; #endif } } #if (DNS_CLIENT_SUPPORT == ENABLED) //Use DNS protocol? if(protocol == HOST_NAME_RESOLVER_DNS) { //Perform host name resolution error = dnsResolve(interface, name, type, ipAddr); } else #endif #if (MDNS_CLIENT_SUPPORT == ENABLED) //Use mDNS protocol? if(protocol == HOST_NAME_RESOLVER_MDNS) { //Perform host name resolution error = mdnsClientResolve(interface, name, type, ipAddr); } else #endif #if (NBNS_CLIENT_SUPPORT == ENABLED && IPV4_SUPPORT == ENABLED) //Use NetBIOS Name Service protocol? if(protocol == HOST_NAME_RESOLVER_NBNS) { //Perform host name resolution error = nbnsResolve(interface, name, ipAddr); } else #endif #if (LLMNR_CLIENT_SUPPORT == ENABLED) //Use LLMNR protocol? if(protocol == HOST_NAME_RESOLVER_LLMNR) { //Perform host name resolution error = llmnrResolve(interface, name, type, ipAddr); } else #endif //Invalid protocol? { //Report an error error = ERROR_INVALID_PARAMETER; } } //Return status code return error; }

345

True

CVE-2021-26788

False

False

False

False

AV:N/AC:L/Au:N/C:N/I:N/A:P

NETWORK

LOW

NONE

NONE

NONE