コード例 #1
0
ファイル: sa.c プロジェクト: repos-holder/openbsd-patches
/* Validate an attribute. Return 0 on match.  */
static int
sa_validate_xf_attrs(u_int16_t type, u_int8_t *value, u_int16_t len,
    void *arg)
{
	int val0, val1;

	struct attr_validation_state *avs =
	    (struct attr_validation_state *)arg;

	LOG_DBG((LOG_SA, 95, "sa_validate_xf_attrs: phase %d mode %d type %d "
	    "len %d", avs->phase, avs->mode, type, len));

	/* Make sure the phase and type are valid.  */
	if (avs->phase == 1) {
		if (type < IKE_ATTR_ENCRYPTION_ALGORITHM ||
		    type > IKE_ATTR_BLOCK_SIZE)
			return 1;
	} else if (avs->phase == 2) {
		if (type < IPSEC_ATTR_SA_LIFE_TYPE ||
		    type > IPSEC_ATTR_ECN_TUNNEL)
			return 1;
	} else
		return 1;

	if (avs->mode == 0) {	/* Load attrs.  */
		avs->attrp[type] = value;
		avs->len[type] = len;
		return 0;
	}
	/* Checking for a missing attribute is an immediate failure.  */
	if (!avs->attrp[type])
		return 1;

	/* Match the loaded attribute against this one, mark it as checked.  */
	avs->checked[type]++;
	switch (len) {
	case 2:
		val0 = (int)decode_16(value);
		break;
	case 4:
		val0 = (int)decode_32(value);
		break;
	default:
		return 1;
	}
	switch (avs->len[type]) {
	case 2:
		val1 = (int)decode_16(avs->attrp[type]);
		break;
	case 4:
		val1 = (int)decode_32(avs->attrp[type]);
		break;
	default:
		return 1;
	}
	/* Return 0 when the values are equal. */
	return (val0 != val1);
}
コード例 #2
0
ファイル: challenge_1_4.c プロジェクト: Ybrad/Portfolio
int main(int argc, char **argv)
{
	if(argc > 1)
	{
		int i;
		char line[60], *bests, *opts = 0, bestc, optc = 0, c, *s;
		uint8_t *val;
		size_t n;
		double optv = 0, bestv, v;
		for(i = 1; i < argc; i++)
		{
			FILE *fp = fopen(argv[i], "r");
			while(fscanf(fp, "%s", line) != EOF)
			{
				n = decode_16(line, &val);
				c = 0;
				bestv = 0.0;
				bestc = 0;
				bests = 0;
				while(++c)
				{
					s = encode_char(xor_1char(val, n, c),n);
					v = score_text(s, n);
					//if(line[0] == '3' && line[1] == 'f' &&
					   //line[2] == '1' && line[3] == 'b')
						//printf("%c :: %s :: %f\n", c, s, v);
					if(v > bestv)
					{
						bestv = v;
						bestc = c;
						//free(bests);
						bests = s;
					}
					//else
					//	free(s);
				}
				//printf("%s : %s\n", line, bests);
				if(bestv > optv)
				{
					optv = bestv;
					optc = bestc;
				//	free(opts);
					opts = bests;
				}
				//else
				//	free(bests);
			}
			fclose(fp);
			printf("File '%s' best guess:\n\tPlain-Text:"
				   "%s\n\tKey:%c\n\tScore:%f\n", 
				   argv[i], opts, optc, optv);
		}
	}
}
コード例 #3
0
ファイル: field.c プロジェクト: ajinkya93/OpenBSD
/*
 * Convert the unsigned LEN-sized number at BUF of network byteorder to a
 * 32-bit unsigned integer of host byteorder pointed to by VAL.
 */
static int
extract_val(u_int8_t *buf, size_t len, u_int32_t *val)
{
	switch (len) {
	case 1:
		*val = *buf;
		break;
	case 2:
		*val = decode_16(buf);
		break;
	case 4:
		*val = decode_32(buf);
		break;
	default:
		return -1;
	}
	return 0;
}
コード例 #4
0
/*
 * Look at the attribute of type TYPE, located at VALUE for LEN bytes forward.
 * The VVS argument holds a validation state kept across invocations.
 * If the attribute is unacceptable to use, return non-zero, otherwise zero.
 */
static int
attribute_unacceptable (u_int16_t type, u_int8_t *value, u_int16_t len,
                        void *vvs)
{
    struct validation_state *vs = vvs;
    struct conf_list *life_conf;
    struct conf_list_node *xf = vs->xf, *life;
    char *tag = constant_lookup (ike_attr_cst, type);
    char *str;
    struct constant_map *map;
    struct attr_node *node;
    int rv;

    if (!tag)
    {
        LOG_DBG ((LOG_NEGOTIATION, 60,
                  "attribute_unacceptable: attribute type %d not known", type));
        return 1;
    }

    switch (type)
    {
    case IKE_ATTR_ENCRYPTION_ALGORITHM:
    case IKE_ATTR_HASH_ALGORITHM:
    case IKE_ATTR_AUTHENTICATION_METHOD:
    case IKE_ATTR_GROUP_DESCRIPTION:
    case IKE_ATTR_GROUP_TYPE:
    case IKE_ATTR_PRF:
        str = conf_get_str (xf->field, tag);
        if (!str)
        {
            /* This attribute does not exist in this policy.  */
            LOG_DBG ((LOG_NEGOTIATION, 70,
                      "attribute_unacceptable: attr %s does not exist in %s",
                      tag, xf->field));
            return 1;
        }

        map = constant_link_lookup (ike_attr_cst, type);
        if (!map)
            return 1;

        if ((constant_value (map, str) == decode_16 (value)) ||
                (!strcmp (str, "ANY")))
        {
            /* Mark this attribute as seen.  */
            node = malloc (sizeof *node);
            if (!node)
            {
                log_error ("attribute_unacceptable: malloc (%lu) failed",
                           (unsigned long)sizeof *node);
                return 1;
            }
            node->type = type;
            LIST_INSERT_HEAD (&vs->attrs, node, link);
            return 0;
        }
        LOG_DBG ((LOG_NEGOTIATION, 30,
                  "attribute_unacceptable: %s: got '%s', expected '%s'", tag,
                  constant_name (map, decode_16 (value)), str));
        return 1;

    case IKE_ATTR_GROUP_PRIME:
    case IKE_ATTR_GROUP_GENERATOR_1:
    case IKE_ATTR_GROUP_GENERATOR_2:
    case IKE_ATTR_GROUP_CURVE_A:
    case IKE_ATTR_GROUP_CURVE_B:
        /* XXX Bignums not handled yet.  */
        return 1;

    case IKE_ATTR_LIFE_TYPE:
    case IKE_ATTR_LIFE_DURATION:
        life_conf = conf_get_list (xf->field, "Life");
        if (life_conf && !strcmp (conf_get_str (xf->field, "Life"), "ANY"))
            return 0;

        rv = 1;
        if (!life_conf)
        {
            /* Life attributes given, but not in our policy.  */
            LOG_DBG ((LOG_NEGOTIATION, 70, "attribute_unacceptable: "
                      "received unexpected life attribute"));
            return 1;
        }

        /*
         * Each lifetime type must match, otherwise we turn the proposal down.
         * In order to do this we need to find the specific section of our
         * policy's "Life" list and match its duration
         */
        switch (type)
        {
        case IKE_ATTR_LIFE_TYPE:
            for (life = TAILQ_FIRST (&life_conf->fields); life;
                    life = TAILQ_NEXT (life, link))
            {
                str = conf_get_str (life->field, "LIFE_TYPE");
                if (!str)
                {
                    LOG_DBG ((LOG_NEGOTIATION, 70, "attribute_unacceptable: "
                              "section [%s] has no LIFE_TYPE", life->field));
                    continue;
                }

                /*
                 * If this is the type we are looking at, save a pointer
                 * to this section in vs->life.
                 */
                if (constant_value (ike_duration_cst, str) == decode_16 (value))
                {
                    vs->life = strdup (life->field);
                    rv = 0;
                    goto bail_out;
                }
            }
            LOG_DBG ((LOG_NEGOTIATION, 70,
                      "attribute_unacceptable: unrecognized LIFE_TYPE %d",
                      decode_16 (value)));
            vs->life = 0;
            break;

        case IKE_ATTR_LIFE_DURATION:
            if (!vs->life)
            {
                LOG_DBG ((LOG_NEGOTIATION, 70, "attribute_unacceptable: "
                          "LIFE_DURATION without LIFE_TYPE"));
                rv = 1;
                goto bail_out;
            }

            str = conf_get_str (vs->life, "LIFE_DURATION");
            if (str)
            {
                if (!strcmp (str, "ANY"))
                    rv = 0;
                else
                    rv = !conf_match_num (vs->life, "LIFE_DURATION",
                                          len == 4 ? decode_32 (value) :
                                          decode_16 (value));
            }
            else
            {
                LOG_DBG ((LOG_NEGOTIATION, 70, "attribute_unacceptable: "
                          "section [%s] has no LIFE_DURATION", vs->life));
                rv = 1;
            }

            free (vs->life);
            vs->life = 0;
            break;
        }

bail_out:
        conf_free_list (life_conf);
        return rv;

    case IKE_ATTR_KEY_LENGTH:
    case IKE_ATTR_FIELD_SIZE:
    case IKE_ATTR_GROUP_ORDER:
        if (conf_match_num (xf->field, tag, decode_16 (value)))
        {
            /* Mark this attribute as seen.  */
            node = malloc (sizeof *node);
            if (!node)
            {
                log_error ("attribute_unacceptable: malloc (%lu) failed",
                           (unsigned long)sizeof *node);
                return 1;
            }
            node->type = type;
            LIST_INSERT_HEAD (&vs->attrs, node, link);
            return 0;
        }
        return 1;
    }
    return 1;
}