pax_global_header00006660000000000000000000000064150552176270014524gustar00rootroot0000000000000052 comment=a2f78e8146433922fab4c6882fafb79e6449be8b pykrb5-0.8.0/000077500000000000000000000000001505521762700127455ustar00rootroot00000000000000pykrb5-0.8.0/.github/000077500000000000000000000000001505521762700143055ustar00rootroot00000000000000pykrb5-0.8.0/.github/workflows/000077500000000000000000000000001505521762700163425ustar00rootroot00000000000000pykrb5-0.8.0/.github/workflows/ci.yml000066400000000000000000000074051505521762700174660ustar00rootroot00000000000000name: Test pykrb5 on: push: branches: - main paths-ignore: - CHANGELOG.md - LICENSE - README.md pull_request: branches: - main paths-ignore: - CHANGELOG.md - LICENSE - README.md release: types: - published jobs: build_sdist: name: build sdist runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - uses: actions/setup-python@v5 with: python-version: 3.12 - name: build sdist run: | python -m pip install build python -m build --sdist env: KRB5_SKIP_EXTENSIONS: true - uses: actions/upload-artifact@v4 with: name: artifact-sdist path: ./dist/*.tar.gz build_wheels: name: build wheels needs: - build_sdist runs-on: ${{ matrix.os }} strategy: fail-fast: false matrix: include: - os: macOS-13 version: cp314-macosx_x86_64 prerelease: true - os: macOS-15 version: cp314-macosx_arm64 prerelease: true - os: macOS-13 version: cp313-macosx_x86_64 - os: macOS-15 version: cp313-macosx_arm64 - os: macOS-13 version: cp312-macosx_x86_64 - os: macOS-15 version: cp312-macosx_arm64 - os: macOS-13 version: cp311-macosx_x86_64 - os: macOS-15 version: cp311-macosx_arm64 - os: macOS-13 version: cp310-macosx_x86_64 - os: macOS-15 version: cp310-macosx_arm64 - os: macOS-13 version: cp39-macosx_x86_64 - os: macOS-15 version: cp39-macosx_arm64 steps: - uses: actions/download-artifact@v5 with: name: artifact-sdist path: ./ - name: extract sdist run: | tar xf krb5-*.tar.gz mv krb5-*/* . rm -r krb5-*/ rm krb5-*.tar.gz - name: build wheel uses: pypa/cibuildwheel@v3.1.4 env: CIBW_BUILD: ${{ matrix.version }} CIBW_BUILD_VERBOSITY: 1 CIBW_PRERELEASE_PYTHONS: ${{ matrix.prerelease || 'false' }} - uses: actions/upload-artifact@v4 with: path: ./wheelhouse/*.whl name: artifact-wheel-${{ matrix.version }} test: name: test needs: - build_sdist - build_wheels runs-on: ${{ matrix.os }} strategy: fail-fast: false matrix: os: - ubuntu-latest - macOS-latest python-version: - 3.9 - '3.10' - '3.11' - '3.12' - '3.13' - '3.14-dev' provider: - mit - heimdal exclude: - os: macOS-latest provider: mit steps: - uses: actions/checkout@v5 - uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - uses: actions/download-artifact@v5 with: pattern: artifact-* merge-multiple: true path: ./dist - name: Test run: sudo -E build_helpers/run-ci.sh env: KRB5_PROVIDER: ${{ matrix.provider }} PYTEST_ADDOPTS: --color=yes - name: Upload Test Results if: always() uses: actions/upload-artifact@v4 with: name: Unit Test Results (${{ matrix.os }} ${{ matrix.provider }} ${{ matrix.python-version }}) path: ./junit/test-results.xml publish: name: publish needs: - test runs-on: ubuntu-latest permissions: # IMPORTANT: this permission is mandatory for trusted publishing id-token: write steps: - uses: actions/download-artifact@v5 with: pattern: artifact-* merge-multiple: true path: ./dist - name: Publish if: startsWith(github.ref, 'refs/tags/v') uses: pypa/gh-action-pypi-publish@release/v1 pykrb5-0.8.0/.gitignore000066400000000000000000000025201505521762700147340ustar00rootroot00000000000000# Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions *.c *.so # Distribution / packaging .Python env/ build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ *.egg-info/ .installed.cfg *.egg __dont_use_cython__.txt # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *.cover .hypothesis/ .pytest_cache/ junit/ # Translations *.mo *.pot # Django stuff: *.log local_settings.py # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ docs/source/ # PyBuilder target/ # Jupyter Notebook .ipynb_checkpoints # pyenv .python-version # celery beat schedule file celerybeat-schedule # SageMath parsed files *.sage.py # dotenv .env !.vscode/.env # virtualenv .venv venv/ ENV/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject # mkdocs documentation /site # mypy .mypy_cache/ # IDEA Files .idea *~ # VSCode Files .vscode/launch.json # MacOS File .DS_Store # Vagrant .vagrant/ # poetry poetry.lock pykrb5-0.8.0/.pre-commit-config.yaml000066400000000000000000000004671505521762700172350ustar00rootroot00000000000000repos: - repo: https://github.com/psf/black rev: 22.10.0 hooks: - id: black - repo: https://github.com/PyCQA/isort rev: 5.10.1 hooks: - id: isort - repo: https://github.com/pre-commit/mirrors-mypy rev: v0.982 hooks: - id: mypy exclude: setup.py additional_dependencies: - pytest pykrb5-0.8.0/.vscode/000077500000000000000000000000001505521762700143065ustar00rootroot00000000000000pykrb5-0.8.0/.vscode/.env000066400000000000000000000000331505521762700150730ustar00rootroot00000000000000PYTHONPATH=src:$PYTHONPATH pykrb5-0.8.0/.vscode/extensions.json000066400000000000000000000001711505521762700173770ustar00rootroot00000000000000{ "recommendations": [ "ms-python.python", "ms-python.vscode-pylance" ] }pykrb5-0.8.0/.vscode/settings.json000066400000000000000000000012231505521762700170370ustar00rootroot00000000000000{ "editor.formatOnSave": true, "editor.rulers": [ 80, 120 ], "files.trimTrailingWhitespace": true, "editor.trimAutoWhitespace": true, "python.formatting.provider": "black", "python.linting.mypyEnabled": true, "python.testing.pytestArgs": [ "tests", "-vv" ], "python.testing.unittestEnabled": false, "python.testing.pytestEnabled": true, "[python]": { "editor.codeActionsOnSave": { "source.organizeImports": "explicit" }, }, "python.linting.ignorePatterns": [ "tests/**" ], "python.envFile": "${workspaceFolder}/.vscode/.env", }pykrb5-0.8.0/.vscode/tasks.json000066400000000000000000000006731505521762700163340ustar00rootroot00000000000000{ // See https://go.microsoft.com/fwlink/?LinkId=733558 // for the documentation about the tasks.json format "version": "2.0.0", "tasks": [ { "label": "Build", "type": "shell", "command": "python setup.py build_ext --inplace", "problemMatcher": [], "group": { "kind": "build", "isDefault": true }, } ] }pykrb5-0.8.0/CHANGELOG.md000066400000000000000000000231671505521762700145670ustar00rootroot00000000000000# Changelog ## 0.8.0 - 2025-09-01 * Require Python 3.9 or newer (dropped 3.8) * Pin Cython build requirements to `3.1.3` for enabling deterministic builds per release ## 0.7.1 - 2025-03-06 * Fix up Cython 0.29.x support when building the library ## 0.7.0 - 2024-10-03 * Require Python 3.8 or newer (dropped 3.7) * Added Python 3.13 wheel for macOS * Added password management APIs * [krb5_chpw_message](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_chpw_message.html) * [krb5_set_password](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_set_password.html) * [krb5_set_password_using_ccache](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_set_password_using_ccache.html) ## 0.6.0 - 2024-07-22 * Fix up wheel package build to not include uneeded `python_krb5.h` file in the final `site-packages` install dir * Added CCache APIs: * [krb5_cc_get_config](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_cc_get_config.html) * [krb5_cc_set_config](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_cc_set_config.html) * Added Context APIs: * [krb5_set_real_time](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_set_real_time.html) * [krb5_timeofday](https://web.mit.edu/Kerberos/krb5-devel/doc/appdev/refs/api/krb5_timeofday.html) * [krb5_us_timeofday](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_us_timeofday.html) * MIT only * [krb5_get_time_offsets](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_get_time_offsets.html) * Added Credential APIs: * [krb5_get_renewed_creds](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_get_renewed_creds.html) * MIT only * [krb5_get_etype_info](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_get_etype_info.html) * [krb5_get_validated_creds](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_get_validated_creds.html) * MIT 1.20+ only * [krb5_marshal_credentials](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_marshal_credentials.html) * [krb5_unmarshal_credentials](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_unmarshal_credentials.html) * Added KeyBlock APIs: * MIT only * [krb5_c_string_to_key](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_c_string_to_key.html) * Added Principal APIs: * [krb5_build_principal]https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_build_principal.html) * Added the following properties to the `Creds` object: * `ticket_flags_raw` - Flags in the ticket as returned by the C API * `ticket_flags` - Flags in the ticket converted to a known enum value * Added the following properties to the `Principal` object: * `realm` - The realm of the principal * `components` - The list of name components. * `type` - The name type of the principal. ## 0.5.1 - 2023-08-29 * Added support for Cython 3.x.y when building the extension modules * Added Python 3.12 wheel for macOS ## 0.5.0 - 2023-02-20 * Added exception that is raised when `krb5.init_context()` failed * Moved back to `setup.cfg` based setuptools project for compatibility with `pip` present on system distributions * Added the following properties to the `Creds` object: * `client` - A copy of the credential's client principal * `server` - A copy of the credential's server principal * `keyblock` - A copy of the credential's session encryption key info * `times` - A copy of the credential's lifetime info including the auth time, star time, end time, and renewal time * `ticket` - A copy of the credential's ticket data * `second_ticket` - A copy of the credential's second ticket data (`DUPLICATE-SKEY` or `ENC-TKT-IN-SKEY`) * Added CCache APIs: * [krb5_cc_remove_cred](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_cc_remove_cred.html) * [krb5_cc_retrieve_cred](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_cc_retrieve_cred.html) * Added Keyblock APIs: * [krb5_copy_keyblock](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_copy_keyblock.html) ## 0.4.1 - 2022-10-25 * Added Python 3.11 wheel ## 0.4.0 - 2022-08-09 * Require Python 3.7 or newer (dropped 3.6) * Created PEP 517 compliant package * Moved all setuptools configuration, except extension information, to `pyproject.toml` * Will no longer include the cythonised `.c` files in the sdist making Cython a build requirement * With PEP 517 this requirement will be automatically satisfied making this a non-breaking change for people using PEP 517 features ## 0.3.0 - 2022-02-16 * Added CCache APIs: * [krb5_cc_set_default_name](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_cc_set_default_name.html) * [krb5_cc_start_seq_get](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_cc_start_seq_get.html#c.krb5_cc_start_seq_get) * [krb5_cc_next_cred](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_cc_next_cred.html#c.krb5_cc_next_cred) * [krb5_cc_end_seq_get](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_cc_end_seq_get.html#c.krb5_cc_end_seq_get) * CCaches can be iterated to get each credential entry in the cache. * Added Keytab management APIs: * [krb5_kt_add_entry](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_kt_add_entry.html) * [krb5_kt_get_entry](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_kt_get_entry.html) * [krb5_kt_have_content](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_kt_have_content.html) * [krb5_kt_read_service_key](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_kt_read_service_key.html) * [krb5_kt_remove_entry](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_kt_remove_entry.html) * [krb5_kt_start_seq_get](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_kt_start_seq_get.html) * [krb5_kt_next_entry](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_kt_next_entry.html) * [krb5_kt_end_seq_get](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_kt_end_seq_get.html) * Keytabs can be iterated to get each entry in the keytab. * Added KeyBlock management APIs: * [krb5_init_keyblock](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_init_keyblock.html) * Due to differences between MIT and Heimdal this function reflects `krb5_keyblock_init` in Heimdal where the data is copied to the keyblock on creation * Added credential options APIs: * [krb5_get_init_creds_opt_set_anonymous](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_get_init_creds_opt_set_anonymous.html) * [krb5_get_init_creds_opt_set_etype_list](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_get_init_creds_opt_set_etype_list.html) * [krb5_get_init_creds_opt_set_in_ccache](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_get_init_creds_opt_set_in_ccache.html) - MIT 1.11 or newer * [krb5_get_init_creds_opt_set_pac_request](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_get_init_creds_opt_set_pac_request.html) - Heimdal or MIT 1.15 * [krb5_get_init_creds_opt_set_proxiable](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_get_init_creds_opt_set_proxiable.html) * [krb5_get_init_creds_opt_set_renew_life](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_get_init_creds_opt_set_renew_life.html) * [krb5_get_init_creds_opt_set_tkt_life](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_get_init_creds_opt_set_tkt_life.html) * [krb5_get_init_creds_opt_set_fast_ccache](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_get_init_creds_opt_set_fast_ccache.html) - MIT only * [krb5_get_init_creds_opt_set_fast_ccache_name](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_get_init_creds_opt_set_fast_ccache_name.html) - MIT only * [krb5_get_init_creds_opt_set_fast_flags](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_get_init_creds_opt_set_fast_flags.html) - MIT only * [krb5_get_init_creds_opt_set_pa](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_get_init_creds_opt_set_pa.html) - MIT only * [krb5_get_init_creds_opt_set_salt](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_get_init_creds_opt_set_salt.html) * Added miscellaneous APIs: * [krb5_copy_principal](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_copy_principal.html) * [krb5_string_to_enctype](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_string_to_enctype.html) * [krb5_enctype_to_string](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_enctype_to_string.html) * [krb5_enctype_to_name](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_enctype_to_name.html) - MIT only ## 0.2.0 - 2021-10-18 * Added [krb5_cc_switch](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_cc_switch.html) * Used to switch the primary credential cache in a collection credential cache * Added [krb5_cc_support_switch](https://github.com/heimdal/heimdal/blob/9dcab76724b417140b4e475701118a01d2892e7c/lib/krb5/cache.c) * Used to detect if a credential cache type, like `FILE`, `DIR`, supports switching with `krb5_cc_switch` * Added [krb5_cc_cache_match](https://web.mit.edu/kerberos/krb5-latest/doc/appdev/refs/api/krb5_cc_cache_match.html) * Retrieve the credential cache inside a collection for the principal specified ## 0.1.2 - 2021-10-06 * Added Python 3.10 wheels ## 0.1.1 - 2021-09-14 * 0.1.0 was taken during registration, use this as the initial release instead ## 0.1.0 - 2021-09-14 Initial release pykrb5-0.8.0/LICENSE000066400000000000000000000020671505521762700137570ustar00rootroot00000000000000MIT License Copyright (c) 2021 Jordan Borean, Red Hat Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. pykrb5-0.8.0/MANIFEST.in000066400000000000000000000004651505521762700145100ustar00rootroot00000000000000include CHANGELOG.md include LICENSE exclude .coverage exclude .gitignore exclude .pre-commit-config.yaml recursive-include build_helpers * include src/krb5/*.h include src/krb5/*.pyx include src/krb5/*.pxd exclude src/krb5/*.c recursive-include stubs * recursive-include tests * recursive-exclude tests *.pycpykrb5-0.8.0/README.md000066400000000000000000000113101505521762700142200ustar00rootroot00000000000000# Python Kerberos 5 Library [![Test workflow](https://github.com/jborean93/pykrb5/actions/workflows/ci.yml/badge.svg)](https://github.com/jborean93/pykrb5/actions/workflows/ci.yml) [![PyPI version](https://badge.fury.io/py/krb5.svg)](https://badge.fury.io/py/krb5) [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/jborean93/pykrb5/blob/main/LICENSE) This library provides Python functions that wraps the Kerberos 5 C API. Due to the complex nature of this API it is highly recommended to use something like [python-gssapi](https://github.com/pythongssapi/python-gssapi) which exposes the Kerberos authentication details through GSSAPI. ## Requirements * An implementation of the Kerberos 5 API - including the header files * [MIT Kebreros](https://web.mit.edu/kerberos/) - Minimum 1.17 * [Heimdal](https://github.com/heimdal/heimdal) * A C compiler, such as GCC * Python 3.9+ _Note: macOS includes their own implementation of Heimdal and a compiler isn't needed on that platform if installing from the wheel._ ## Installation Simply run: ```bash pip install krb5 ``` To install from source run the following: ```bash git clone https://github.com/jborean93/pykrb5.git python -m pip install build python -m build pip install dist/krb5-*.whl ``` Compiling the code should automatically pick up the proper paths for the KRB5 headers and locations. If further customisation is needed, the following environment variables can be set when building the wheel: * `KRB5_KRB5CONFIG` * The path to `krb5-config` to use for detecting the Kerberos library to link to * The compiler and linker args are derived from what this function outputs * Defaults to whatever `krb5-config` is on the `PATH` * FreeBSD will default to `/usr/local/bin/krb5-config` instead of `/usr/bin/krb5-config` * `KRB5_MAIN_LIB` * The path to the `libkrb5` shared library used to check if any of the optional functions are available * `KRB5_COMPILER_ARGS` * Compiler flags to use when compiling the extensions * Defaults to the output of `krb5-config --cflags krb5` if not set * `KRB5_LINKER_ARGS` * Linker flags to use when compiling the extensions * Defaults to the output of `krb5-config --libs krb5` if not set * `KRB5_SKIP_MODULE_CHECK` * Skips the checks used to detect if optional functions are available - will treat them all as available * This is only really useful when building the sdist as no implementation provides all these functions * `KRB5_CYTHON_TRACING` * Used to generate the Cython extensions with line tracing for coverage collection * `KRB5_MACOS_HEIMDAL_DIR` * Used when compiling on macOS to point to the Heimdal install directory * Used to find the Heimdal header files as macOS does not include, or provide a way to obtain, these header files for their Heimdal framework * Defaults to `{git_root}/build_helpers/heimdal` ## Development To run the tests or make changes to this repo run the following: ```bash git clone https://github.com/jborean93/pykrb5.git pip install -r requirements-dev.txt pre-commit install python -m pip install -e . # Can compile the krb5 extensions on an adhoc basis # python setup.py build_ext --inplace ``` From there an editor like VSCode can be used to make changes and run the test suite. To recompile the Cython files after a change run the `build_ext --inplace` command. ## Structure This library is merely a wrapper around the Kerberos 5 APIs. The functions under the `krb5` namespace match the KRB5 API specification but with the `krb5_` prefix remove. For example the [krb5_init_context](https://web.mit.edu/kerberos/krb5-devel/doc/appdev/refs/api/krb5_init_context.html) function is called through `krb5.init_context()`. Errors are raised as a `Krb5Error` which contains the message as formatted by the KRB5 implementation and the error code for that error. Some of the structures returned by these functions are represented by a Python class and are freed once they are deallocated once all references to that object is removed. Some classes expose an `addr` property that returns the raw pointer address of the structure it is wrapping. This is so the structure can be used in other libraries like `python-gssapi` but great care must be taken that nothing else frees the structure as that could cause a segmentation fault. Not all the functions exposed in this library are available on every KRB5 API implementation. To check if a function is available run the following: ```python import krb5 if not hasattr(krb5, "kt_dup"): raise Exception("Current implementation does not support krb5_kt_dup") ``` There may also be some difference in behaviour, error codes, error messages, between te different implementations. It is up to the caller to paper over these differences when required. pykrb5-0.8.0/build_helpers/000077500000000000000000000000001505521762700155665ustar00rootroot00000000000000pykrb5-0.8.0/build_helpers/heimdal/000077500000000000000000000000001505521762700171715ustar00rootroot00000000000000pykrb5-0.8.0/build_helpers/heimdal/include/000077500000000000000000000000001505521762700206145ustar00rootroot00000000000000pykrb5-0.8.0/build_helpers/heimdal/include/asn1-common.h000066400000000000000000000042041505521762700231150ustar00rootroot00000000000000/* $Id$ */ #include #include #include #ifndef __asn1_common_definitions__ #define __asn1_common_definitions__ #ifndef __HEIM_BASE_DATA__ #define __HEIM_BASE_DATA__ 1 struct heim_base_data { size_t length; void *data; }; #endif typedef struct heim_integer { size_t length; void *data; int negative; } heim_integer; typedef struct heim_base_data heim_octet_string; typedef char *heim_general_string; typedef char *heim_utf8_string; typedef struct heim_base_data heim_printable_string; typedef struct heim_base_data heim_ia5_string; typedef struct heim_bmp_string { size_t length; uint16_t *data; } heim_bmp_string; typedef struct heim_universal_string { size_t length; uint32_t *data; } heim_universal_string; typedef char *heim_visible_string; typedef struct heim_oid { size_t length; unsigned *components; } heim_oid; typedef struct heim_bit_string { size_t length; void *data; } heim_bit_string; typedef struct heim_base_data heim_any; typedef struct heim_base_data heim_any_set; #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \ do { \ (BL) = length_##T((S)); \ (B) = malloc((BL)); \ if((B) == NULL) { \ (R) = ENOMEM; \ } else { \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (S), (L)); \ if((R) != 0) { \ free((B)); \ (B) = NULL; \ } \ } \ } while (0) #ifdef _WIN32 #ifndef ASN1_LIB #define ASN1EXP __declspec(dllimport) #else #define ASN1EXP #endif #define ASN1CALL __stdcall #else #define ASN1EXP #define ASN1CALL #endif #endif pykrb5-0.8.0/build_helpers/heimdal/include/asn1_err.h000066400000000000000000000020501505521762700224740ustar00rootroot00000000000000/* Generated from asn1_err.et */ /* $Id$ */ #ifndef __asn1_err_h__ #define __asn1_err_h__ struct et_list; void initialize_asn1_error_table_r(struct et_list **); void initialize_asn1_error_table(void); #define init_asn1_err_tbl initialize_asn1_error_table typedef enum asn1_error_number{ ASN1_BAD_TIMEFORMAT = 1859794432, ASN1_MISSING_FIELD = 1859794433, ASN1_MISPLACED_FIELD = 1859794434, ASN1_TYPE_MISMATCH = 1859794435, ASN1_OVERFLOW = 1859794436, ASN1_OVERRUN = 1859794437, ASN1_BAD_ID = 1859794438, ASN1_BAD_LENGTH = 1859794439, ASN1_BAD_FORMAT = 1859794440, ASN1_PARSE_ERROR = 1859794441, ASN1_EXTRA_DATA = 1859794442, ASN1_BAD_CHARACTER = 1859794443, ASN1_MIN_CONSTRAINT = 1859794444, ASN1_MAX_CONSTRAINT = 1859794445, ASN1_EXACT_CONSTRAINT = 1859794446, ASN1_INDEF_OVERRUN = 1859794447, ASN1_INDEF_UNDERRUN = 1859794448, ASN1_GOT_BER = 1859794449, ASN1_INDEF_EXTRA_DATA = 1859794450 } asn1_error_number; #define ERROR_TABLE_BASE_asn1 1859794432 #define COM_ERR_BINDDOMAIN_asn1 "heim_com_err1859794432" #endif /* __asn1_err_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/base64.h000066400000000000000000000037731505521762700220630ustar00rootroot00000000000000/* * Copyright (c) 1995, 1996, 1997 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef _BASE64_H_ #define _BASE64_H_ #ifndef ROKEN_LIB_FUNCTION #ifdef _WIN32 #define ROKEN_LIB_FUNCTION #define ROKEN_LIB_CALL __cdecl #else #define ROKEN_LIB_FUNCTION #define ROKEN_LIB_CALL #endif #endif ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL rk_base64_encode(const void *, int, char **); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL rk_base64_decode(const char *, void *); #endif pykrb5-0.8.0/build_helpers/heimdal/include/cms_asn1.h000066400000000000000000000664221505521762700225030ustar00rootroot00000000000000/* Generated from ./cms.asn1 */ /* Do not edit */ #ifndef __cms_asn1_h__ #define __cms_asn1_h__ #include #include #ifndef __asn1_common_definitions__ #define __asn1_common_definitions__ #ifndef __HEIM_BASE_DATA__ #define __HEIM_BASE_DATA__ 1 struct heim_base_data { size_t length; void *data; }; typedef struct heim_base_data heim_octet_string; #endif typedef struct heim_integer { size_t length; void *data; int negative; } heim_integer; typedef char *heim_general_string; typedef char *heim_utf8_string; typedef struct heim_base_data heim_printable_string; typedef struct heim_base_data heim_ia5_string; typedef struct heim_bmp_string { size_t length; uint16_t *data; } heim_bmp_string; typedef struct heim_universal_string { size_t length; uint32_t *data; } heim_universal_string; typedef char *heim_visible_string; typedef struct heim_oid { size_t length; unsigned *components; } heim_oid; typedef struct heim_bit_string { size_t length; void *data; } heim_bit_string; typedef struct heim_base_data heim_any; typedef struct heim_base_data heim_any_set; #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \ do { \ (BL) = length_##T((S)); \ (B) = malloc((BL)); \ if((B) == NULL) { \ (R) = ENOMEM; \ } else { \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (S), (L)); \ if((R) != 0) { \ free((B)); \ (B) = NULL; \ } \ } \ } while (0) #ifdef _WIN32 #ifndef ASN1_LIB #define ASN1EXP __declspec(dllimport) #else #define ASN1EXP #endif #define ASN1CALL __stdcall #else #define ASN1EXP #define ASN1CALL #endif struct units; #endif #include #include /* OBJECT IDENTIFIER id-pkcs7 ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs7(7) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs7; #define ASN1_OID_ID_PKCS7 (&asn1_oid_id_pkcs7) /* OBJECT IDENTIFIER id-pkcs7-data ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs7(7) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs7_data; #define ASN1_OID_ID_PKCS7_DATA (&asn1_oid_id_pkcs7_data) /* OBJECT IDENTIFIER id-pkcs7-signedData ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs7(7) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs7_signedData; #define ASN1_OID_ID_PKCS7_SIGNEDDATA (&asn1_oid_id_pkcs7_signedData) /* OBJECT IDENTIFIER id-pkcs7-envelopedData ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs7(7) label-less(3) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs7_envelopedData; #define ASN1_OID_ID_PKCS7_ENVELOPEDDATA (&asn1_oid_id_pkcs7_envelopedData) /* OBJECT IDENTIFIER id-pkcs7-signedAndEnvelopedData ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs7(7) label-less(4) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs7_signedAndEnvelopedData; #define ASN1_OID_ID_PKCS7_SIGNEDANDENVELOPEDDATA (&asn1_oid_id_pkcs7_signedAndEnvelopedData) /* OBJECT IDENTIFIER id-pkcs7-digestedData ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs7(7) label-less(5) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs7_digestedData; #define ASN1_OID_ID_PKCS7_DIGESTEDDATA (&asn1_oid_id_pkcs7_digestedData) /* OBJECT IDENTIFIER id-pkcs7-encryptedData ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs7(7) label-less(6) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs7_encryptedData; #define ASN1_OID_ID_PKCS7_ENCRYPTEDDATA (&asn1_oid_id_pkcs7_encryptedData) /* CMSVersion ::= INTEGER { CMSVersion_v0(0), CMSVersion_v1(1), CMSVersion_v2(2), CMSVersion_v3(3), CMSVersion_v4(4) } */ typedef enum CMSVersion { CMSVersion_v0 = 0, CMSVersion_v1 = 1, CMSVersion_v2 = 2, CMSVersion_v3 = 3, CMSVersion_v4 = 4 } CMSVersion; ASN1EXP int ASN1CALL decode_CMSVersion(const unsigned char *, size_t, CMSVersion *, size_t *); ASN1EXP int ASN1CALL encode_CMSVersion(unsigned char *, size_t, const CMSVersion *, size_t *); ASN1EXP size_t ASN1CALL length_CMSVersion(const CMSVersion *); ASN1EXP int ASN1CALL copy_CMSVersion (const CMSVersion *, CMSVersion *); ASN1EXP void ASN1CALL free_CMSVersion (CMSVersion *); /* DigestAlgorithmIdentifier ::= AlgorithmIdentifier */ typedef AlgorithmIdentifier DigestAlgorithmIdentifier; ASN1EXP int ASN1CALL decode_DigestAlgorithmIdentifier(const unsigned char *, size_t, DigestAlgorithmIdentifier *, size_t *); ASN1EXP int ASN1CALL encode_DigestAlgorithmIdentifier(unsigned char *, size_t, const DigestAlgorithmIdentifier *, size_t *); ASN1EXP size_t ASN1CALL length_DigestAlgorithmIdentifier(const DigestAlgorithmIdentifier *); ASN1EXP int ASN1CALL copy_DigestAlgorithmIdentifier (const DigestAlgorithmIdentifier *, DigestAlgorithmIdentifier *); ASN1EXP void ASN1CALL free_DigestAlgorithmIdentifier (DigestAlgorithmIdentifier *); /* DigestAlgorithmIdentifiers ::= SET OF DigestAlgorithmIdentifier */ typedef struct DigestAlgorithmIdentifiers { unsigned int len; DigestAlgorithmIdentifier *val; } DigestAlgorithmIdentifiers; ASN1EXP int ASN1CALL add_DigestAlgorithmIdentifiers (DigestAlgorithmIdentifiers *, const DigestAlgorithmIdentifier *); ASN1EXP int ASN1CALL remove_DigestAlgorithmIdentifiers (DigestAlgorithmIdentifiers *, unsigned int); ASN1EXP int ASN1CALL decode_DigestAlgorithmIdentifiers(const unsigned char *, size_t, DigestAlgorithmIdentifiers *, size_t *); ASN1EXP int ASN1CALL encode_DigestAlgorithmIdentifiers(unsigned char *, size_t, const DigestAlgorithmIdentifiers *, size_t *); ASN1EXP size_t ASN1CALL length_DigestAlgorithmIdentifiers(const DigestAlgorithmIdentifiers *); ASN1EXP int ASN1CALL copy_DigestAlgorithmIdentifiers (const DigestAlgorithmIdentifiers *, DigestAlgorithmIdentifiers *); ASN1EXP void ASN1CALL free_DigestAlgorithmIdentifiers (DigestAlgorithmIdentifiers *); /* SignatureAlgorithmIdentifier ::= AlgorithmIdentifier */ typedef AlgorithmIdentifier SignatureAlgorithmIdentifier; ASN1EXP int ASN1CALL decode_SignatureAlgorithmIdentifier(const unsigned char *, size_t, SignatureAlgorithmIdentifier *, size_t *); ASN1EXP int ASN1CALL encode_SignatureAlgorithmIdentifier(unsigned char *, size_t, const SignatureAlgorithmIdentifier *, size_t *); ASN1EXP size_t ASN1CALL length_SignatureAlgorithmIdentifier(const SignatureAlgorithmIdentifier *); ASN1EXP int ASN1CALL copy_SignatureAlgorithmIdentifier (const SignatureAlgorithmIdentifier *, SignatureAlgorithmIdentifier *); ASN1EXP void ASN1CALL free_SignatureAlgorithmIdentifier (SignatureAlgorithmIdentifier *); /* ContentType ::= OBJECT IDENTIFIER */ typedef heim_oid ContentType; ASN1EXP int ASN1CALL decode_ContentType(const unsigned char *, size_t, ContentType *, size_t *); ASN1EXP int ASN1CALL encode_ContentType(unsigned char *, size_t, const ContentType *, size_t *); ASN1EXP size_t ASN1CALL length_ContentType(const ContentType *); ASN1EXP int ASN1CALL copy_ContentType (const ContentType *, ContentType *); ASN1EXP void ASN1CALL free_ContentType (ContentType *); /* MessageDigest ::= OCTET STRING */ typedef heim_octet_string MessageDigest; ASN1EXP int ASN1CALL decode_MessageDigest(const unsigned char *, size_t, MessageDigest *, size_t *); ASN1EXP int ASN1CALL encode_MessageDigest(unsigned char *, size_t, const MessageDigest *, size_t *); ASN1EXP size_t ASN1CALL length_MessageDigest(const MessageDigest *); ASN1EXP int ASN1CALL copy_MessageDigest (const MessageDigest *, MessageDigest *); ASN1EXP void ASN1CALL free_MessageDigest (MessageDigest *); /* ContentInfo ::= SEQUENCE { contentType ContentType, content [0] heim_any OPTIONAL, } */ typedef struct ContentInfo { ContentType contentType; heim_any *content; } ContentInfo; ASN1EXP int ASN1CALL decode_ContentInfo(const unsigned char *, size_t, ContentInfo *, size_t *); ASN1EXP int ASN1CALL encode_ContentInfo(unsigned char *, size_t, const ContentInfo *, size_t *); ASN1EXP size_t ASN1CALL length_ContentInfo(const ContentInfo *); ASN1EXP int ASN1CALL copy_ContentInfo (const ContentInfo *, ContentInfo *); ASN1EXP void ASN1CALL free_ContentInfo (ContentInfo *); /* EncapsulatedContentInfo ::= SEQUENCE { eContentType ContentType, eContent [0] OCTET STRING OPTIONAL, } */ typedef struct EncapsulatedContentInfo { ContentType eContentType; heim_octet_string *eContent; } EncapsulatedContentInfo; ASN1EXP int ASN1CALL decode_EncapsulatedContentInfo(const unsigned char *, size_t, EncapsulatedContentInfo *, size_t *); ASN1EXP int ASN1CALL encode_EncapsulatedContentInfo(unsigned char *, size_t, const EncapsulatedContentInfo *, size_t *); ASN1EXP size_t ASN1CALL length_EncapsulatedContentInfo(const EncapsulatedContentInfo *); ASN1EXP int ASN1CALL copy_EncapsulatedContentInfo (const EncapsulatedContentInfo *, EncapsulatedContentInfo *); ASN1EXP void ASN1CALL free_EncapsulatedContentInfo (EncapsulatedContentInfo *); /* CertificateSet ::= SET OF heim_any */ typedef struct CertificateSet { unsigned int len; heim_any *val; } CertificateSet; ASN1EXP int ASN1CALL decode_CertificateSet(const unsigned char *, size_t, CertificateSet *, size_t *); ASN1EXP int ASN1CALL encode_CertificateSet(unsigned char *, size_t, const CertificateSet *, size_t *); ASN1EXP size_t ASN1CALL length_CertificateSet(const CertificateSet *); ASN1EXP int ASN1CALL copy_CertificateSet (const CertificateSet *, CertificateSet *); ASN1EXP void ASN1CALL free_CertificateSet (CertificateSet *); /* CertificateList ::= Certificate */ typedef Certificate CertificateList; ASN1EXP int ASN1CALL decode_CertificateList(const unsigned char *, size_t, CertificateList *, size_t *); ASN1EXP int ASN1CALL encode_CertificateList(unsigned char *, size_t, const CertificateList *, size_t *); ASN1EXP size_t ASN1CALL length_CertificateList(const CertificateList *); ASN1EXP int ASN1CALL copy_CertificateList (const CertificateList *, CertificateList *); ASN1EXP void ASN1CALL free_CertificateList (CertificateList *); /* CertificateRevocationLists ::= SET OF CertificateList */ typedef struct CertificateRevocationLists { unsigned int len; CertificateList *val; } CertificateRevocationLists; ASN1EXP int ASN1CALL decode_CertificateRevocationLists(const unsigned char *, size_t, CertificateRevocationLists *, size_t *); ASN1EXP int ASN1CALL encode_CertificateRevocationLists(unsigned char *, size_t, const CertificateRevocationLists *, size_t *); ASN1EXP size_t ASN1CALL length_CertificateRevocationLists(const CertificateRevocationLists *); ASN1EXP int ASN1CALL copy_CertificateRevocationLists (const CertificateRevocationLists *, CertificateRevocationLists *); ASN1EXP void ASN1CALL free_CertificateRevocationLists (CertificateRevocationLists *); /* IssuerAndSerialNumber ::= SEQUENCE { issuer Name, serialNumber CertificateSerialNumber, } */ typedef struct IssuerAndSerialNumber { Name issuer; CertificateSerialNumber serialNumber; } IssuerAndSerialNumber; ASN1EXP int ASN1CALL decode_IssuerAndSerialNumber(const unsigned char *, size_t, IssuerAndSerialNumber *, size_t *); ASN1EXP int ASN1CALL encode_IssuerAndSerialNumber(unsigned char *, size_t, const IssuerAndSerialNumber *, size_t *); ASN1EXP size_t ASN1CALL length_IssuerAndSerialNumber(const IssuerAndSerialNumber *); ASN1EXP int ASN1CALL copy_IssuerAndSerialNumber (const IssuerAndSerialNumber *, IssuerAndSerialNumber *); ASN1EXP void ASN1CALL free_IssuerAndSerialNumber (IssuerAndSerialNumber *); /* CMSIdentifier ::= CHOICE { issuerAndSerialNumber IssuerAndSerialNumber, subjectKeyIdentifier [0] SubjectKeyIdentifier, } */ typedef struct CMSIdentifier { enum CMSIdentifier_enum { choice_CMSIdentifier_issuerAndSerialNumber = 1, choice_CMSIdentifier_subjectKeyIdentifier } element; union { IssuerAndSerialNumber issuerAndSerialNumber; SubjectKeyIdentifier subjectKeyIdentifier; } u; } CMSIdentifier; ASN1EXP int ASN1CALL decode_CMSIdentifier(const unsigned char *, size_t, CMSIdentifier *, size_t *); ASN1EXP int ASN1CALL encode_CMSIdentifier(unsigned char *, size_t, const CMSIdentifier *, size_t *); ASN1EXP size_t ASN1CALL length_CMSIdentifier(const CMSIdentifier *); ASN1EXP int ASN1CALL copy_CMSIdentifier (const CMSIdentifier *, CMSIdentifier *); ASN1EXP void ASN1CALL free_CMSIdentifier (CMSIdentifier *); /* SignerIdentifier ::= CMSIdentifier */ typedef CMSIdentifier SignerIdentifier; ASN1EXP int ASN1CALL decode_SignerIdentifier(const unsigned char *, size_t, SignerIdentifier *, size_t *); ASN1EXP int ASN1CALL encode_SignerIdentifier(unsigned char *, size_t, const SignerIdentifier *, size_t *); ASN1EXP size_t ASN1CALL length_SignerIdentifier(const SignerIdentifier *); ASN1EXP int ASN1CALL copy_SignerIdentifier (const SignerIdentifier *, SignerIdentifier *); ASN1EXP void ASN1CALL free_SignerIdentifier (SignerIdentifier *); /* RecipientIdentifier ::= CMSIdentifier */ typedef CMSIdentifier RecipientIdentifier; ASN1EXP int ASN1CALL decode_RecipientIdentifier(const unsigned char *, size_t, RecipientIdentifier *, size_t *); ASN1EXP int ASN1CALL encode_RecipientIdentifier(unsigned char *, size_t, const RecipientIdentifier *, size_t *); ASN1EXP size_t ASN1CALL length_RecipientIdentifier(const RecipientIdentifier *); ASN1EXP int ASN1CALL copy_RecipientIdentifier (const RecipientIdentifier *, RecipientIdentifier *); ASN1EXP void ASN1CALL free_RecipientIdentifier (RecipientIdentifier *); /* CMSAttributes ::= SET OF Attribute */ typedef struct CMSAttributes { unsigned int len; Attribute *val; } CMSAttributes; ASN1EXP int ASN1CALL decode_CMSAttributes(const unsigned char *, size_t, CMSAttributes *, size_t *); ASN1EXP int ASN1CALL encode_CMSAttributes(unsigned char *, size_t, const CMSAttributes *, size_t *); ASN1EXP size_t ASN1CALL length_CMSAttributes(const CMSAttributes *); ASN1EXP int ASN1CALL copy_CMSAttributes (const CMSAttributes *, CMSAttributes *); ASN1EXP void ASN1CALL free_CMSAttributes (CMSAttributes *); /* SignatureValue ::= OCTET STRING */ typedef heim_octet_string SignatureValue; ASN1EXP int ASN1CALL decode_SignatureValue(const unsigned char *, size_t, SignatureValue *, size_t *); ASN1EXP int ASN1CALL encode_SignatureValue(unsigned char *, size_t, const SignatureValue *, size_t *); ASN1EXP size_t ASN1CALL length_SignatureValue(const SignatureValue *); ASN1EXP int ASN1CALL copy_SignatureValue (const SignatureValue *, SignatureValue *); ASN1EXP void ASN1CALL free_SignatureValue (SignatureValue *); /* SignerInfo ::= SEQUENCE { version CMSVersion, sid SignerIdentifier, digestAlgorithm DigestAlgorithmIdentifier, signedAttrs [0] IMPLICIT SET OF Attribute OPTIONAL, signatureAlgorithm SignatureAlgorithmIdentifier, signature SignatureValue, unsignedAttrs [1] IMPLICIT SET OF Attribute OPTIONAL, } */ typedef struct SignerInfo { CMSVersion version; SignerIdentifier sid; DigestAlgorithmIdentifier digestAlgorithm; struct SignerInfo_signedAttrs { unsigned int len; Attribute *val; } *signedAttrs; SignatureAlgorithmIdentifier signatureAlgorithm; SignatureValue signature; struct SignerInfo_unsignedAttrs { unsigned int len; Attribute *val; } *unsignedAttrs; } SignerInfo; ASN1EXP int ASN1CALL decode_SignerInfo(const unsigned char *, size_t, SignerInfo *, size_t *); ASN1EXP int ASN1CALL encode_SignerInfo(unsigned char *, size_t, const SignerInfo *, size_t *); ASN1EXP size_t ASN1CALL length_SignerInfo(const SignerInfo *); ASN1EXP int ASN1CALL copy_SignerInfo (const SignerInfo *, SignerInfo *); ASN1EXP void ASN1CALL free_SignerInfo (SignerInfo *); /* SignerInfos ::= SET OF SignerInfo */ typedef struct SignerInfos { unsigned int len; SignerInfo *val; } SignerInfos; ASN1EXP int ASN1CALL decode_SignerInfos(const unsigned char *, size_t, SignerInfos *, size_t *); ASN1EXP int ASN1CALL encode_SignerInfos(unsigned char *, size_t, const SignerInfos *, size_t *); ASN1EXP size_t ASN1CALL length_SignerInfos(const SignerInfos *); ASN1EXP int ASN1CALL copy_SignerInfos (const SignerInfos *, SignerInfos *); ASN1EXP void ASN1CALL free_SignerInfos (SignerInfos *); /* SignedData ::= SEQUENCE { version CMSVersion, digestAlgorithms DigestAlgorithmIdentifiers, encapContentInfo EncapsulatedContentInfo, certificates [0] IMPLICIT SET OF heim_any OPTIONAL, crls [1] IMPLICIT heim_any OPTIONAL, signerInfos SignerInfos, } */ typedef struct SignedData { CMSVersion version; DigestAlgorithmIdentifiers digestAlgorithms; EncapsulatedContentInfo encapContentInfo; struct SignedData_certificates { unsigned int len; heim_any *val; } *certificates; heim_any *crls; SignerInfos signerInfos; } SignedData; ASN1EXP int ASN1CALL decode_SignedData(const unsigned char *, size_t, SignedData *, size_t *); ASN1EXP int ASN1CALL encode_SignedData(unsigned char *, size_t, const SignedData *, size_t *); ASN1EXP size_t ASN1CALL length_SignedData(const SignedData *); ASN1EXP int ASN1CALL copy_SignedData (const SignedData *, SignedData *); ASN1EXP void ASN1CALL free_SignedData (SignedData *); /* OriginatorInfo ::= SEQUENCE { certs [0] IMPLICIT SET OF heim_any OPTIONAL, crls [1] IMPLICIT heim_any OPTIONAL, } */ typedef struct OriginatorInfo { struct OriginatorInfo_certs { unsigned int len; heim_any *val; } *certs; heim_any *crls; } OriginatorInfo; ASN1EXP int ASN1CALL decode_OriginatorInfo(const unsigned char *, size_t, OriginatorInfo *, size_t *); ASN1EXP int ASN1CALL encode_OriginatorInfo(unsigned char *, size_t, const OriginatorInfo *, size_t *); ASN1EXP size_t ASN1CALL length_OriginatorInfo(const OriginatorInfo *); ASN1EXP int ASN1CALL copy_OriginatorInfo (const OriginatorInfo *, OriginatorInfo *); ASN1EXP void ASN1CALL free_OriginatorInfo (OriginatorInfo *); /* KeyEncryptionAlgorithmIdentifier ::= AlgorithmIdentifier */ typedef AlgorithmIdentifier KeyEncryptionAlgorithmIdentifier; ASN1EXP int ASN1CALL decode_KeyEncryptionAlgorithmIdentifier(const unsigned char *, size_t, KeyEncryptionAlgorithmIdentifier *, size_t *); ASN1EXP int ASN1CALL encode_KeyEncryptionAlgorithmIdentifier(unsigned char *, size_t, const KeyEncryptionAlgorithmIdentifier *, size_t *); ASN1EXP size_t ASN1CALL length_KeyEncryptionAlgorithmIdentifier(const KeyEncryptionAlgorithmIdentifier *); ASN1EXP int ASN1CALL copy_KeyEncryptionAlgorithmIdentifier (const KeyEncryptionAlgorithmIdentifier *, KeyEncryptionAlgorithmIdentifier *); ASN1EXP void ASN1CALL free_KeyEncryptionAlgorithmIdentifier (KeyEncryptionAlgorithmIdentifier *); /* ContentEncryptionAlgorithmIdentifier ::= AlgorithmIdentifier */ typedef AlgorithmIdentifier ContentEncryptionAlgorithmIdentifier; ASN1EXP int ASN1CALL decode_ContentEncryptionAlgorithmIdentifier(const unsigned char *, size_t, ContentEncryptionAlgorithmIdentifier *, size_t *); ASN1EXP int ASN1CALL encode_ContentEncryptionAlgorithmIdentifier(unsigned char *, size_t, const ContentEncryptionAlgorithmIdentifier *, size_t *); ASN1EXP size_t ASN1CALL length_ContentEncryptionAlgorithmIdentifier(const ContentEncryptionAlgorithmIdentifier *); ASN1EXP int ASN1CALL copy_ContentEncryptionAlgorithmIdentifier (const ContentEncryptionAlgorithmIdentifier *, ContentEncryptionAlgorithmIdentifier *); ASN1EXP void ASN1CALL free_ContentEncryptionAlgorithmIdentifier (ContentEncryptionAlgorithmIdentifier *); /* EncryptedKey ::= OCTET STRING */ typedef heim_octet_string EncryptedKey; ASN1EXP int ASN1CALL decode_EncryptedKey(const unsigned char *, size_t, EncryptedKey *, size_t *); ASN1EXP int ASN1CALL encode_EncryptedKey(unsigned char *, size_t, const EncryptedKey *, size_t *); ASN1EXP size_t ASN1CALL length_EncryptedKey(const EncryptedKey *); ASN1EXP int ASN1CALL copy_EncryptedKey (const EncryptedKey *, EncryptedKey *); ASN1EXP void ASN1CALL free_EncryptedKey (EncryptedKey *); /* KeyTransRecipientInfo ::= SEQUENCE { version CMSVersion, rid RecipientIdentifier, keyEncryptionAlgorithm KeyEncryptionAlgorithmIdentifier, encryptedKey EncryptedKey, } */ typedef struct KeyTransRecipientInfo { CMSVersion version; RecipientIdentifier rid; KeyEncryptionAlgorithmIdentifier keyEncryptionAlgorithm; EncryptedKey encryptedKey; } KeyTransRecipientInfo; ASN1EXP int ASN1CALL decode_KeyTransRecipientInfo(const unsigned char *, size_t, KeyTransRecipientInfo *, size_t *); ASN1EXP int ASN1CALL encode_KeyTransRecipientInfo(unsigned char *, size_t, const KeyTransRecipientInfo *, size_t *); ASN1EXP size_t ASN1CALL length_KeyTransRecipientInfo(const KeyTransRecipientInfo *); ASN1EXP int ASN1CALL copy_KeyTransRecipientInfo (const KeyTransRecipientInfo *, KeyTransRecipientInfo *); ASN1EXP void ASN1CALL free_KeyTransRecipientInfo (KeyTransRecipientInfo *); /* RecipientInfo ::= KeyTransRecipientInfo */ typedef KeyTransRecipientInfo RecipientInfo; ASN1EXP int ASN1CALL decode_RecipientInfo(const unsigned char *, size_t, RecipientInfo *, size_t *); ASN1EXP int ASN1CALL encode_RecipientInfo(unsigned char *, size_t, const RecipientInfo *, size_t *); ASN1EXP size_t ASN1CALL length_RecipientInfo(const RecipientInfo *); ASN1EXP int ASN1CALL copy_RecipientInfo (const RecipientInfo *, RecipientInfo *); ASN1EXP void ASN1CALL free_RecipientInfo (RecipientInfo *); /* RecipientInfos ::= SET OF RecipientInfo */ typedef struct RecipientInfos { unsigned int len; RecipientInfo *val; } RecipientInfos; ASN1EXP int ASN1CALL decode_RecipientInfos(const unsigned char *, size_t, RecipientInfos *, size_t *); ASN1EXP int ASN1CALL encode_RecipientInfos(unsigned char *, size_t, const RecipientInfos *, size_t *); ASN1EXP size_t ASN1CALL length_RecipientInfos(const RecipientInfos *); ASN1EXP int ASN1CALL copy_RecipientInfos (const RecipientInfos *, RecipientInfos *); ASN1EXP void ASN1CALL free_RecipientInfos (RecipientInfos *); /* EncryptedContent ::= OCTET STRING */ typedef heim_octet_string EncryptedContent; ASN1EXP int ASN1CALL decode_EncryptedContent(const unsigned char *, size_t, EncryptedContent *, size_t *); ASN1EXP int ASN1CALL encode_EncryptedContent(unsigned char *, size_t, const EncryptedContent *, size_t *); ASN1EXP size_t ASN1CALL length_EncryptedContent(const EncryptedContent *); ASN1EXP int ASN1CALL copy_EncryptedContent (const EncryptedContent *, EncryptedContent *); ASN1EXP void ASN1CALL free_EncryptedContent (EncryptedContent *); /* EncryptedContentInfo ::= SEQUENCE { contentType ContentType, contentEncryptionAlgorithm ContentEncryptionAlgorithmIdentifier, encryptedContent [0] IMPLICIT OCTET STRING OPTIONAL, } */ typedef struct EncryptedContentInfo { ContentType contentType; ContentEncryptionAlgorithmIdentifier contentEncryptionAlgorithm; heim_octet_string *encryptedContent; } EncryptedContentInfo; ASN1EXP int ASN1CALL decode_EncryptedContentInfo(const unsigned char *, size_t, EncryptedContentInfo *, size_t *); ASN1EXP int ASN1CALL encode_EncryptedContentInfo(unsigned char *, size_t, const EncryptedContentInfo *, size_t *); ASN1EXP size_t ASN1CALL length_EncryptedContentInfo(const EncryptedContentInfo *); ASN1EXP int ASN1CALL copy_EncryptedContentInfo (const EncryptedContentInfo *, EncryptedContentInfo *); ASN1EXP void ASN1CALL free_EncryptedContentInfo (EncryptedContentInfo *); /* UnprotectedAttributes ::= SET OF Attribute */ typedef struct UnprotectedAttributes { unsigned int len; Attribute *val; } UnprotectedAttributes; ASN1EXP int ASN1CALL decode_UnprotectedAttributes(const unsigned char *, size_t, UnprotectedAttributes *, size_t *); ASN1EXP int ASN1CALL encode_UnprotectedAttributes(unsigned char *, size_t, const UnprotectedAttributes *, size_t *); ASN1EXP size_t ASN1CALL length_UnprotectedAttributes(const UnprotectedAttributes *); ASN1EXP int ASN1CALL copy_UnprotectedAttributes (const UnprotectedAttributes *, UnprotectedAttributes *); ASN1EXP void ASN1CALL free_UnprotectedAttributes (UnprotectedAttributes *); /* CMSEncryptedData ::= SEQUENCE { version CMSVersion, encryptedContentInfo EncryptedContentInfo, unprotectedAttrs [1] IMPLICIT heim_any OPTIONAL, } */ typedef struct CMSEncryptedData { CMSVersion version; EncryptedContentInfo encryptedContentInfo; heim_any *unprotectedAttrs; } CMSEncryptedData; ASN1EXP int ASN1CALL decode_CMSEncryptedData(const unsigned char *, size_t, CMSEncryptedData *, size_t *); ASN1EXP int ASN1CALL encode_CMSEncryptedData(unsigned char *, size_t, const CMSEncryptedData *, size_t *); ASN1EXP size_t ASN1CALL length_CMSEncryptedData(const CMSEncryptedData *); ASN1EXP int ASN1CALL copy_CMSEncryptedData (const CMSEncryptedData *, CMSEncryptedData *); ASN1EXP void ASN1CALL free_CMSEncryptedData (CMSEncryptedData *); /* EnvelopedData ::= SEQUENCE { version CMSVersion, originatorInfo [0] IMPLICIT heim_any OPTIONAL, recipientInfos RecipientInfos, encryptedContentInfo EncryptedContentInfo, unprotectedAttrs [1] IMPLICIT heim_any OPTIONAL, } */ typedef struct EnvelopedData { CMSVersion version; heim_any *originatorInfo; RecipientInfos recipientInfos; EncryptedContentInfo encryptedContentInfo; heim_any *unprotectedAttrs; } EnvelopedData; ASN1EXP int ASN1CALL decode_EnvelopedData(const unsigned char *, size_t, EnvelopedData *, size_t *); ASN1EXP int ASN1CALL encode_EnvelopedData(unsigned char *, size_t, const EnvelopedData *, size_t *); ASN1EXP size_t ASN1CALL length_EnvelopedData(const EnvelopedData *); ASN1EXP int ASN1CALL copy_EnvelopedData (const EnvelopedData *, EnvelopedData *); ASN1EXP void ASN1CALL free_EnvelopedData (EnvelopedData *); /* CMSRC2CBCParameter ::= SEQUENCE { rc2ParameterVersion INTEGER (0..4294967295), iv OCTET STRING, } */ typedef struct CMSRC2CBCParameter { unsigned int rc2ParameterVersion; heim_octet_string iv; } CMSRC2CBCParameter; ASN1EXP int ASN1CALL decode_CMSRC2CBCParameter(const unsigned char *, size_t, CMSRC2CBCParameter *, size_t *); ASN1EXP int ASN1CALL encode_CMSRC2CBCParameter(unsigned char *, size_t, const CMSRC2CBCParameter *, size_t *); ASN1EXP size_t ASN1CALL length_CMSRC2CBCParameter(const CMSRC2CBCParameter *); ASN1EXP int ASN1CALL copy_CMSRC2CBCParameter (const CMSRC2CBCParameter *, CMSRC2CBCParameter *); ASN1EXP void ASN1CALL free_CMSRC2CBCParameter (CMSRC2CBCParameter *); /* CMSCBCParameter ::= OCTET STRING */ typedef heim_octet_string CMSCBCParameter; ASN1EXP int ASN1CALL decode_CMSCBCParameter(const unsigned char *, size_t, CMSCBCParameter *, size_t *); ASN1EXP int ASN1CALL encode_CMSCBCParameter(unsigned char *, size_t, const CMSCBCParameter *, size_t *); ASN1EXP size_t ASN1CALL length_CMSCBCParameter(const CMSCBCParameter *); ASN1EXP int ASN1CALL copy_CMSCBCParameter (const CMSCBCParameter *, CMSCBCParameter *); ASN1EXP void ASN1CALL free_CMSCBCParameter (CMSCBCParameter *); #endif /* __cms_asn1_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/com_err.h000066400000000000000000000052131505521762700224140ustar00rootroot00000000000000/* * Copyright (c) 1997 - 2001 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ /* MIT compatible com_err library */ #ifndef __COM_ERR_H__ #define __COM_ERR_H__ #include #include #if !defined(__GNUC__) && !defined(__attribute__) #define __attribute__(X) #endif typedef void (KRB5_CALLCONV *errf) (const char *, long, const char *, va_list); KRB5_LIB_FUNCTION const char * KRB5_LIB_CALL error_message (long); KRB5_LIB_FUNCTION int KRB5_LIB_CALL init_error_table (const char**, long, int); KRB5_LIB_FUNCTION void KRB5_LIB_CALL com_err_va (const char *, long, const char *, va_list) __attribute__ ((__format__ (__printf__, 3, 0))); KRB5_LIB_FUNCTION void KRB5_LIB_CALL com_err (const char *, long, const char *, ...) __attribute__ ((__format__ (__printf__, 3, 4))); KRB5_LIB_FUNCTION errf KRB5_LIB_CALL set_com_err_hook (errf); KRB5_LIB_FUNCTION errf KRB5_LIB_CALL reset_com_err_hook (void); KRB5_LIB_FUNCTION const char * KRB5_LIB_CALL error_table_name (int num); KRB5_LIB_FUNCTION void KRB5_LIB_CALL add_to_error_table (struct et_list *new_table); #endif /* __COM_ERR_H__ */ pykrb5-0.8.0/build_helpers/heimdal/include/com_right.h000066400000000000000000000053051505521762700227430ustar00rootroot00000000000000/* * Copyright (c) 1997 - 2000 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef __COM_RIGHT_H__ #define __COM_RIGHT_H__ #ifndef KRB5_LIB #ifndef KRB5_LIB_FUNCTION #if defined(_WIN32) #define KRB5_LIB_FUNCTION __declspec(dllimport) #define KRB5_LIB_CALL __stdcall #define KRB5_LIB_VARIABLE __declspec(dllimport) #else #define KRB5_LIB_FUNCTION #define KRB5_LIB_CALL #define KRB5_LIB_VARIABLE #endif #endif #endif #ifdef _WIN32 #define KRB5_CALLCONV __stdcall #else #define KRB5_CALLCONV #endif #ifdef __STDC__ #include #include #endif struct error_table { char const * const * msgs; long base; int n_msgs; }; struct et_list { struct et_list *next; struct error_table *table; }; extern struct et_list *_et_list; KRB5_LIB_FUNCTION const char * KRB5_LIB_CALL com_right (struct et_list *list, long code); KRB5_LIB_FUNCTION const char * KRB5_LIB_CALL com_right_r (struct et_list *list, long code, char *, size_t); KRB5_LIB_FUNCTION void KRB5_LIB_CALL initialize_error_table_r (struct et_list **, const char **, int, long); KRB5_LIB_FUNCTION void KRB5_LIB_CALL free_error_table (struct et_list *); #endif /* __COM_RIGHT_H__ */ pykrb5-0.8.0/build_helpers/heimdal/include/crmf_asn1.h000066400000000000000000000327461505521762700226520ustar00rootroot00000000000000/* Generated from ./crmf.asn1 */ /* Do not edit */ #ifndef __crmf_asn1_h__ #define __crmf_asn1_h__ #include #include #ifndef __asn1_common_definitions__ #define __asn1_common_definitions__ #ifndef __HEIM_BASE_DATA__ #define __HEIM_BASE_DATA__ 1 struct heim_base_data { size_t length; void *data; }; typedef struct heim_base_data heim_octet_string; #endif typedef struct heim_integer { size_t length; void *data; int negative; } heim_integer; typedef char *heim_general_string; typedef char *heim_utf8_string; typedef struct heim_base_data heim_printable_string; typedef struct heim_base_data heim_ia5_string; typedef struct heim_bmp_string { size_t length; uint16_t *data; } heim_bmp_string; typedef struct heim_universal_string { size_t length; uint32_t *data; } heim_universal_string; typedef char *heim_visible_string; typedef struct heim_oid { size_t length; unsigned *components; } heim_oid; typedef struct heim_bit_string { size_t length; void *data; } heim_bit_string; typedef struct heim_base_data heim_any; typedef struct heim_base_data heim_any_set; #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \ do { \ (BL) = length_##T((S)); \ (B) = malloc((BL)); \ if((B) == NULL) { \ (R) = ENOMEM; \ } else { \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (S), (L)); \ if((R) != 0) { \ free((B)); \ (B) = NULL; \ } \ } \ } while (0) #ifdef _WIN32 #ifndef ASN1_LIB #define ASN1EXP __declspec(dllimport) #else #define ASN1EXP #endif #define ASN1CALL __stdcall #else #define ASN1EXP #define ASN1CALL #endif struct units; #endif #include #include /* CRMFRDNSequence ::= SEQUENCE OF RelativeDistinguishedName */ typedef struct CRMFRDNSequence { unsigned int len; RelativeDistinguishedName *val; } CRMFRDNSequence; ASN1EXP int ASN1CALL decode_CRMFRDNSequence(const unsigned char *, size_t, CRMFRDNSequence *, size_t *); ASN1EXP int ASN1CALL encode_CRMFRDNSequence(unsigned char *, size_t, const CRMFRDNSequence *, size_t *); ASN1EXP size_t ASN1CALL length_CRMFRDNSequence(const CRMFRDNSequence *); ASN1EXP int ASN1CALL copy_CRMFRDNSequence (const CRMFRDNSequence *, CRMFRDNSequence *); ASN1EXP void ASN1CALL free_CRMFRDNSequence (CRMFRDNSequence *); /* Controls ::= SEQUENCE OF AttributeTypeAndValue */ typedef struct Controls { unsigned int len; AttributeTypeAndValue *val; } Controls; ASN1EXP int ASN1CALL decode_Controls(const unsigned char *, size_t, Controls *, size_t *); ASN1EXP int ASN1CALL encode_Controls(unsigned char *, size_t, const Controls *, size_t *); ASN1EXP size_t ASN1CALL length_Controls(const Controls *); ASN1EXP int ASN1CALL copy_Controls (const Controls *, Controls *); ASN1EXP void ASN1CALL free_Controls (Controls *); /* POPOSigningKey ::= SEQUENCE { poposkInput [0] IMPLICIT POPOSigningKeyInput OPTIONAL, algorithmIdentifier AlgorithmIdentifier, signature BIT STRING { }, } */ typedef struct POPOSigningKey { POPOSigningKeyInput *poposkInput; AlgorithmIdentifier algorithmIdentifier; heim_bit_string signature; } POPOSigningKey; ASN1EXP int ASN1CALL decode_POPOSigningKey(const unsigned char *, size_t, POPOSigningKey *, size_t *); ASN1EXP int ASN1CALL encode_POPOSigningKey(unsigned char *, size_t, const POPOSigningKey *, size_t *); ASN1EXP size_t ASN1CALL length_POPOSigningKey(const POPOSigningKey *); ASN1EXP int ASN1CALL copy_POPOSigningKey (const POPOSigningKey *, POPOSigningKey *); ASN1EXP void ASN1CALL free_POPOSigningKey (POPOSigningKey *); /* PKMACValue ::= SEQUENCE { algId AlgorithmIdentifier, value BIT STRING { }, } */ typedef struct PKMACValue { AlgorithmIdentifier algId; heim_bit_string value; } PKMACValue; ASN1EXP int ASN1CALL decode_PKMACValue(const unsigned char *, size_t, PKMACValue *, size_t *); ASN1EXP int ASN1CALL encode_PKMACValue(unsigned char *, size_t, const PKMACValue *, size_t *); ASN1EXP size_t ASN1CALL length_PKMACValue(const PKMACValue *); ASN1EXP int ASN1CALL copy_PKMACValue (const PKMACValue *, PKMACValue *); ASN1EXP void ASN1CALL free_PKMACValue (PKMACValue *); /* POPOSigningKeyInput ::= SEQUENCE { authInfo CHOICE { sender [0] IMPLICIT GeneralName, publicKeyMAC PKMACValue, }, publicKey SubjectPublicKeyInfo, } */ typedef struct POPOSigningKeyInput { struct POPOSigningKeyInput_authInfo { enum POPOSigningKeyInput_authInfo_enum { choice_POPOSigningKeyInput_authInfo_sender = 1, choice_POPOSigningKeyInput_authInfo_publicKeyMAC } element; union { GeneralName sender; PKMACValue publicKeyMAC; } u; } authInfo; SubjectPublicKeyInfo publicKey; } POPOSigningKeyInput; ASN1EXP int ASN1CALL decode_POPOSigningKeyInput(const unsigned char *, size_t, POPOSigningKeyInput *, size_t *); ASN1EXP int ASN1CALL encode_POPOSigningKeyInput(unsigned char *, size_t, const POPOSigningKeyInput *, size_t *); ASN1EXP size_t ASN1CALL length_POPOSigningKeyInput(const POPOSigningKeyInput *); ASN1EXP int ASN1CALL copy_POPOSigningKeyInput (const POPOSigningKeyInput *, POPOSigningKeyInput *); ASN1EXP void ASN1CALL free_POPOSigningKeyInput (POPOSigningKeyInput *); /* PBMParameter ::= SEQUENCE { salt OCTET STRING, owf AlgorithmIdentifier, iterationCount INTEGER, mac AlgorithmIdentifier, } */ typedef struct PBMParameter { heim_octet_string salt; AlgorithmIdentifier owf; heim_integer iterationCount; AlgorithmIdentifier mac; } PBMParameter; ASN1EXP int ASN1CALL decode_PBMParameter(const unsigned char *, size_t, PBMParameter *, size_t *); ASN1EXP int ASN1CALL encode_PBMParameter(unsigned char *, size_t, const PBMParameter *, size_t *); ASN1EXP size_t ASN1CALL length_PBMParameter(const PBMParameter *); ASN1EXP int ASN1CALL copy_PBMParameter (const PBMParameter *, PBMParameter *); ASN1EXP void ASN1CALL free_PBMParameter (PBMParameter *); /* SubsequentMessage ::= INTEGER { encrCert(0), challengeResp(1) } */ typedef enum SubsequentMessage { encrCert = 0, challengeResp = 1 } SubsequentMessage; ASN1EXP int ASN1CALL decode_SubsequentMessage(const unsigned char *, size_t, SubsequentMessage *, size_t *); ASN1EXP int ASN1CALL encode_SubsequentMessage(unsigned char *, size_t, const SubsequentMessage *, size_t *); ASN1EXP size_t ASN1CALL length_SubsequentMessage(const SubsequentMessage *); ASN1EXP int ASN1CALL copy_SubsequentMessage (const SubsequentMessage *, SubsequentMessage *); ASN1EXP void ASN1CALL free_SubsequentMessage (SubsequentMessage *); /* POPOPrivKey ::= CHOICE { thisMessage [0] BIT STRING { }, subsequentMessage [1] IMPLICIT SubsequentMessage, dhMAC [2] BIT STRING { }, agreeMAC [3] IMPLICIT PKMACValue, encryptedKey [4] heim_any, } */ typedef struct POPOPrivKey { enum POPOPrivKey_enum { choice_POPOPrivKey_thisMessage = 1, choice_POPOPrivKey_subsequentMessage, choice_POPOPrivKey_dhMAC, choice_POPOPrivKey_agreeMAC, choice_POPOPrivKey_encryptedKey } element; union { heim_bit_string thisMessage; SubsequentMessage subsequentMessage; heim_bit_string dhMAC; PKMACValue agreeMAC; heim_any encryptedKey; } u; } POPOPrivKey; ASN1EXP int ASN1CALL decode_POPOPrivKey(const unsigned char *, size_t, POPOPrivKey *, size_t *); ASN1EXP int ASN1CALL encode_POPOPrivKey(unsigned char *, size_t, const POPOPrivKey *, size_t *); ASN1EXP size_t ASN1CALL length_POPOPrivKey(const POPOPrivKey *); ASN1EXP int ASN1CALL copy_POPOPrivKey (const POPOPrivKey *, POPOPrivKey *); ASN1EXP void ASN1CALL free_POPOPrivKey (POPOPrivKey *); /* ProofOfPossession ::= CHOICE { raVerified [0] NULL, signature [1] POPOSigningKey, keyEncipherment [2] POPOPrivKey, keyAgreement [3] POPOPrivKey, } */ typedef struct ProofOfPossession { enum ProofOfPossession_enum { choice_ProofOfPossession_raVerified = 1, choice_ProofOfPossession_signature, choice_ProofOfPossession_keyEncipherment, choice_ProofOfPossession_keyAgreement } element; union { int raVerified; POPOSigningKey signature; POPOPrivKey keyEncipherment; POPOPrivKey keyAgreement; } u; } ProofOfPossession; ASN1EXP int ASN1CALL decode_ProofOfPossession(const unsigned char *, size_t, ProofOfPossession *, size_t *); ASN1EXP int ASN1CALL encode_ProofOfPossession(unsigned char *, size_t, const ProofOfPossession *, size_t *); ASN1EXP size_t ASN1CALL length_ProofOfPossession(const ProofOfPossession *); ASN1EXP int ASN1CALL copy_ProofOfPossession (const ProofOfPossession *, ProofOfPossession *); ASN1EXP void ASN1CALL free_ProofOfPossession (ProofOfPossession *); /* CertTemplate ::= SEQUENCE { version [0] INTEGER OPTIONAL, serialNumber [1] INTEGER OPTIONAL, signingAlg [2] SEQUENCE { algorithm OBJECT IDENTIFIER, parameters heim_any OPTIONAL, } OPTIONAL, issuer [3] IMPLICIT CHOICE { rdnSequence CRMFRDNSequence, } OPTIONAL, validity [4] SEQUENCE { notBefore [0] Time OPTIONAL, notAfter [1] Time OPTIONAL, } OPTIONAL, subject [5] IMPLICIT CHOICE { rdnSequence CRMFRDNSequence, } OPTIONAL, publicKey [6] IMPLICIT SEQUENCE { algorithm AlgorithmIdentifier, subjectPublicKey BIT STRING { } OPTIONAL, } OPTIONAL, issuerUID [7] IMPLICIT BIT STRING { } OPTIONAL, subjectUID [8] IMPLICIT BIT STRING { } OPTIONAL, extensions [9] IMPLICIT SEQUENCE OF Extension OPTIONAL, } */ typedef struct CertTemplate { heim_integer *version; heim_integer *serialNumber; struct CertTemplate_signingAlg { heim_oid algorithm; heim_any *parameters; } *signingAlg; struct CertTemplate_issuer { enum CertTemplate_issuer_enum { choice_CertTemplate_issuer_rdnSequence = 1 } element; union { CRMFRDNSequence rdnSequence; } u; } *issuer; struct CertTemplate_validity { Time *notBefore; Time *notAfter; } *validity; struct CertTemplate_subject { enum CertTemplate_subject_enum { choice_CertTemplate_subject_rdnSequence = 1 } element; union { CRMFRDNSequence rdnSequence; } u; } *subject; struct CertTemplate_publicKey { AlgorithmIdentifier algorithm; heim_bit_string *subjectPublicKey; } *publicKey; heim_bit_string *issuerUID; heim_bit_string *subjectUID; struct CertTemplate_extensions { unsigned int len; Extension *val; } *extensions; } CertTemplate; ASN1EXP int ASN1CALL decode_CertTemplate(const unsigned char *, size_t, CertTemplate *, size_t *); ASN1EXP int ASN1CALL encode_CertTemplate(unsigned char *, size_t, const CertTemplate *, size_t *); ASN1EXP size_t ASN1CALL length_CertTemplate(const CertTemplate *); ASN1EXP int ASN1CALL copy_CertTemplate (const CertTemplate *, CertTemplate *); ASN1EXP void ASN1CALL free_CertTemplate (CertTemplate *); /* CertRequest ::= SEQUENCE { certReqId INTEGER, certTemplate CertTemplate, controls Controls OPTIONAL, } */ typedef struct CertRequest { heim_integer certReqId; CertTemplate certTemplate; Controls *controls; } CertRequest; ASN1EXP int ASN1CALL decode_CertRequest(const unsigned char *, size_t, CertRequest *, size_t *); ASN1EXP int ASN1CALL encode_CertRequest(unsigned char *, size_t, const CertRequest *, size_t *); ASN1EXP size_t ASN1CALL length_CertRequest(const CertRequest *); ASN1EXP int ASN1CALL copy_CertRequest (const CertRequest *, CertRequest *); ASN1EXP void ASN1CALL free_CertRequest (CertRequest *); /* CertReqMsg ::= SEQUENCE { certReq CertRequest, popo ProofOfPossession OPTIONAL, regInfo SEQUENCE OF AttributeTypeAndValue OPTIONAL, } */ typedef struct CertReqMsg { CertRequest certReq; ProofOfPossession *popo; struct CertReqMsg_regInfo { unsigned int len; AttributeTypeAndValue *val; } *regInfo; } CertReqMsg; ASN1EXP int ASN1CALL decode_CertReqMsg(const unsigned char *, size_t, CertReqMsg *, size_t *); ASN1EXP int ASN1CALL encode_CertReqMsg(unsigned char *, size_t, const CertReqMsg *, size_t *); ASN1EXP size_t ASN1CALL length_CertReqMsg(const CertReqMsg *); ASN1EXP int ASN1CALL copy_CertReqMsg (const CertReqMsg *, CertReqMsg *); ASN1EXP void ASN1CALL free_CertReqMsg (CertReqMsg *); /* CertReqMessages ::= SEQUENCE OF CertReqMsg */ typedef struct CertReqMessages { unsigned int len; CertReqMsg *val; } CertReqMessages; ASN1EXP int ASN1CALL decode_CertReqMessages(const unsigned char *, size_t, CertReqMessages *, size_t *); ASN1EXP int ASN1CALL encode_CertReqMessages(unsigned char *, size_t, const CertReqMessages *, size_t *); ASN1EXP size_t ASN1CALL length_CertReqMessages(const CertReqMessages *); ASN1EXP int ASN1CALL copy_CertReqMessages (const CertReqMessages *, CertReqMessages *); ASN1EXP void ASN1CALL free_CertReqMessages (CertReqMessages *); #endif /* __crmf_asn1_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/der-private.h000066400000000000000000000037501505521762700232140ustar00rootroot00000000000000/* This is a generated file */ #ifndef __der_private_h__ #define __der_private_h__ #include int _asn1_bmember_isset_bit ( const void */*data*/, unsigned int /*bit*/, size_t /*size*/); void _asn1_bmember_put_bit ( unsigned char */*p*/, const void */*data*/, unsigned int /*bit*/, size_t /*size*/, unsigned int */*bitset*/); int _asn1_copy ( const struct asn1_template */*t*/, const void */*from*/, void */*to*/); int _asn1_copy_top ( const struct asn1_template */*t*/, const void */*from*/, void */*to*/); int _asn1_decode ( const struct asn1_template */*t*/, unsigned /*flags*/, const unsigned char */*p*/, size_t /*len*/, void */*data*/, size_t */*size*/); int _asn1_decode_top ( const struct asn1_template */*t*/, unsigned /*flags*/, const unsigned char */*p*/, size_t /*len*/, void */*data*/, size_t */*size*/); int _asn1_encode ( const struct asn1_template */*t*/, unsigned char */*p*/, size_t /*len*/, const void */*data*/, size_t */*size*/); int _asn1_encode_fuzzer ( const struct asn1_template */*t*/, unsigned char */*p*/, size_t /*len*/, const void */*data*/, size_t */*size*/); void _asn1_free ( const struct asn1_template */*t*/, void */*data*/); void _asn1_free_top ( const struct asn1_template */*t*/, void */*data*/); size_t _asn1_length ( const struct asn1_template */*t*/, const void */*data*/); size_t _asn1_length_fuzzer ( const struct asn1_template */*t*/, const void */*data*/); size_t _asn1_sizeofType (const struct asn1_template */*t*/); struct tm * _der_gmtime ( time_t /*t*/, struct tm */*tm*/); int _heim_der_set_sort ( const void */*a1*/, const void */*a2*/); int _heim_fix_dce ( size_t /*reallen*/, size_t */*len*/); size_t _heim_len_int (int /*val*/); size_t _heim_len_int64 (int64_t /*val*/); size_t _heim_len_unsigned (unsigned /*val*/); size_t _heim_len_unsigned64 (uint64_t /*val*/); int _heim_time2generalizedtime ( time_t /*t*/, heim_octet_string */*s*/, int /*gtimep*/); #endif /* __der_private_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/der-protos.h000066400000000000000000000266721505521762700231000ustar00rootroot00000000000000/* This is a generated file */ #ifndef __der_protos_h__ #define __der_protos_h__ #ifndef DOXY #include #ifdef __cplusplus extern "C" { #endif int asn1_fuzzer_done (void); int asn1_fuzzer_method (const char */*mode*/); void asn1_fuzzer_next (void); void asn1_fuzzer_reset (void); int copy_heim_any ( const heim_any */*from*/, heim_any */*to*/); int copy_heim_any_set ( const heim_any_set */*from*/, heim_any_set */*to*/); int decode_heim_any ( const unsigned char */*p*/, size_t /*len*/, heim_any */*data*/, size_t */*size*/); int decode_heim_any_set ( const unsigned char */*p*/, size_t /*len*/, heim_any_set */*data*/, size_t */*size*/); int der_copy_bit_string ( const heim_bit_string */*from*/, heim_bit_string */*to*/); int der_copy_bmp_string ( const heim_bmp_string */*from*/, heim_bmp_string */*to*/); int der_copy_general_string ( const heim_general_string */*from*/, heim_general_string */*to*/); int der_copy_generalized_time ( const time_t */*from*/, time_t */*to*/); int der_copy_heim_integer ( const heim_integer */*from*/, heim_integer */*to*/); int der_copy_ia5_string ( const heim_ia5_string */*from*/, heim_ia5_string */*to*/); int der_copy_integer ( const int */*from*/, int */*to*/); int der_copy_integer64 ( const int64_t */*from*/, int64_t */*to*/); int der_copy_octet_string ( const heim_octet_string */*from*/, heim_octet_string */*to*/); int der_copy_oid ( const heim_oid */*from*/, heim_oid */*to*/); int der_copy_printable_string ( const heim_printable_string */*from*/, heim_printable_string */*to*/); int der_copy_universal_string ( const heim_universal_string */*from*/, heim_universal_string */*to*/); int der_copy_unsigned ( const unsigned */*from*/, unsigned */*to*/); int der_copy_unsigned64 ( const uint64_t */*from*/, uint64_t */*to*/); int der_copy_utctime ( const time_t */*from*/, time_t */*to*/); int der_copy_utf8string ( const heim_utf8_string */*from*/, heim_utf8_string */*to*/); int der_copy_visible_string ( const heim_visible_string */*from*/, heim_visible_string */*to*/); void der_free_bit_string (heim_bit_string */*k*/); void der_free_bmp_string (heim_bmp_string */*k*/); void der_free_general_string (heim_general_string */*str*/); void der_free_generalized_time (time_t */*t*/); void der_free_heim_integer (heim_integer */*k*/); void der_free_ia5_string (heim_ia5_string */*str*/); void der_free_integer (int */*i*/); void der_free_integer64 (int64_t */*i*/); void der_free_octet_string (heim_octet_string */*k*/); void der_free_oid (heim_oid */*k*/); void der_free_printable_string (heim_printable_string */*str*/); void der_free_universal_string (heim_universal_string */*k*/); void der_free_unsigned (unsigned */*u*/); void der_free_unsigned64 (uint64_t */*u*/); void der_free_utctime (time_t */*t*/); void der_free_utf8string (heim_utf8_string */*str*/); void der_free_visible_string (heim_visible_string */*str*/); int der_get_bit_string ( const unsigned char */*p*/, size_t /*len*/, heim_bit_string */*data*/, size_t */*size*/); int der_get_bmp_string ( const unsigned char */*p*/, size_t /*len*/, heim_bmp_string */*data*/, size_t */*size*/); int der_get_boolean ( const unsigned char */*p*/, size_t /*len*/, int */*data*/, size_t */*size*/); const char * der_get_class_name (unsigned /*num*/); int der_get_class_num (const char */*name*/); int der_get_general_string ( const unsigned char */*p*/, size_t /*len*/, heim_general_string */*str*/, size_t */*size*/); int der_get_generalized_time ( const unsigned char */*p*/, size_t /*len*/, time_t */*data*/, size_t */*size*/); int der_get_heim_integer ( const unsigned char */*p*/, size_t /*len*/, heim_integer */*data*/, size_t */*size*/); int der_get_ia5_string ( const unsigned char */*p*/, size_t /*len*/, heim_ia5_string */*str*/, size_t */*size*/); int der_get_integer ( const unsigned char */*p*/, size_t /*len*/, int */*ret*/, size_t */*size*/); int der_get_integer64 ( const unsigned char */*p*/, size_t /*len*/, int64_t */*ret*/, size_t */*size*/); int der_get_length ( const unsigned char */*p*/, size_t /*len*/, size_t */*val*/, size_t */*size*/); int der_get_octet_string ( const unsigned char */*p*/, size_t /*len*/, heim_octet_string */*data*/, size_t */*size*/); int der_get_octet_string_ber ( const unsigned char */*p*/, size_t /*len*/, heim_octet_string */*data*/, size_t */*size*/); int der_get_oid ( const unsigned char */*p*/, size_t /*len*/, heim_oid */*data*/, size_t */*size*/); int der_get_printable_string ( const unsigned char */*p*/, size_t /*len*/, heim_printable_string */*str*/, size_t */*size*/); int der_get_tag ( const unsigned char */*p*/, size_t /*len*/, Der_class */*cls*/, Der_type */*type*/, unsigned int */*tag*/, size_t */*size*/); const char * der_get_tag_name (unsigned /*num*/); int der_get_tag_num (const char */*name*/); const char * der_get_type_name (unsigned /*num*/); int der_get_type_num (const char */*name*/); int der_get_universal_string ( const unsigned char */*p*/, size_t /*len*/, heim_universal_string */*data*/, size_t */*size*/); int der_get_unsigned ( const unsigned char */*p*/, size_t /*len*/, unsigned */*ret*/, size_t */*size*/); int der_get_unsigned64 ( const unsigned char */*p*/, size_t /*len*/, uint64_t */*ret*/, size_t */*size*/); int der_get_utctime ( const unsigned char */*p*/, size_t /*len*/, time_t */*data*/, size_t */*size*/); int der_get_utf8string ( const unsigned char */*p*/, size_t /*len*/, heim_utf8_string */*str*/, size_t */*size*/); int der_get_visible_string ( const unsigned char */*p*/, size_t /*len*/, heim_visible_string */*str*/, size_t */*size*/); int der_heim_bit_string_cmp ( const heim_bit_string */*p*/, const heim_bit_string */*q*/); int der_heim_bmp_string_cmp ( const heim_bmp_string */*p*/, const heim_bmp_string */*q*/); int der_heim_integer_cmp ( const heim_integer */*p*/, const heim_integer */*q*/); int der_heim_octet_string_cmp ( const heim_octet_string */*p*/, const heim_octet_string */*q*/); int der_heim_oid_cmp ( const heim_oid */*p*/, const heim_oid */*q*/); int der_heim_universal_string_cmp ( const heim_universal_string */*p*/, const heim_universal_string */*q*/); int der_ia5_string_cmp ( const heim_ia5_string */*p*/, const heim_ia5_string */*q*/); size_t der_length_bit_string (const heim_bit_string */*k*/); size_t der_length_bmp_string (const heim_bmp_string */*data*/); size_t der_length_boolean (const int */*k*/); size_t der_length_enumerated (const unsigned */*data*/); size_t der_length_general_string (const heim_general_string */*data*/); size_t der_length_generalized_time (const time_t */*t*/); size_t der_length_heim_integer (const heim_integer */*k*/); size_t der_length_ia5_string (const heim_ia5_string */*data*/); size_t der_length_integer (const int */*data*/); size_t der_length_integer64 (const int64_t */*data*/); size_t der_length_len (size_t /*len*/); size_t der_length_octet_string (const heim_octet_string */*k*/); size_t der_length_oid (const heim_oid */*k*/); size_t der_length_printable_string (const heim_printable_string */*data*/); size_t der_length_tag (unsigned int /*tag*/); size_t der_length_universal_string (const heim_universal_string */*data*/); size_t der_length_unsigned (const unsigned */*data*/); size_t der_length_unsigned64 (const uint64_t */*data*/); size_t der_length_utctime (const time_t */*t*/); size_t der_length_utf8string (const heim_utf8_string */*data*/); size_t der_length_visible_string (const heim_visible_string */*data*/); int der_match_tag ( const unsigned char */*p*/, size_t /*len*/, Der_class /*cls*/, Der_type /*type*/, unsigned int /*tag*/, size_t */*size*/); int der_match_tag2 ( const unsigned char */*p*/, size_t /*len*/, Der_class /*cls*/, Der_type */*type*/, unsigned int /*tag*/, size_t */*size*/); int der_match_tag_and_length ( const unsigned char */*p*/, size_t /*len*/, Der_class /*cls*/, Der_type */*type*/, unsigned int /*tag*/, size_t */*length_ret*/, size_t */*size*/); int der_parse_heim_oid ( const char */*str*/, const char */*sep*/, heim_oid */*data*/); int der_parse_hex_heim_integer ( const char */*p*/, heim_integer */*data*/); int der_print_heim_oid ( const heim_oid */*oid*/, char /*delim*/, char **/*str*/); int der_print_hex_heim_integer ( const heim_integer */*data*/, char **/*p*/); int der_printable_string_cmp ( const heim_printable_string */*p*/, const heim_printable_string */*q*/); int der_put_bit_string ( unsigned char */*p*/, size_t /*len*/, const heim_bit_string */*data*/, size_t */*size*/); int der_put_bmp_string ( unsigned char */*p*/, size_t /*len*/, const heim_bmp_string */*data*/, size_t */*size*/); int der_put_boolean ( unsigned char */*p*/, size_t /*len*/, const int */*data*/, size_t */*size*/); int der_put_general_string ( unsigned char */*p*/, size_t /*len*/, const heim_general_string */*str*/, size_t */*size*/); int der_put_generalized_time ( unsigned char */*p*/, size_t /*len*/, const time_t */*data*/, size_t */*size*/); int der_put_heim_integer ( unsigned char */*p*/, size_t /*len*/, const heim_integer */*data*/, size_t */*size*/); int der_put_ia5_string ( unsigned char */*p*/, size_t /*len*/, const heim_ia5_string */*str*/, size_t */*size*/); int der_put_integer ( unsigned char */*p*/, size_t /*len*/, const int */*v*/, size_t */*size*/); int der_put_integer64 ( unsigned char */*p*/, size_t /*len*/, const int64_t */*v*/, size_t */*size*/); int der_put_length ( unsigned char */*p*/, size_t /*len*/, size_t /*val*/, size_t */*size*/); int der_put_length_and_tag ( unsigned char */*p*/, size_t /*len*/, size_t /*len_val*/, Der_class /*class*/, Der_type /*type*/, unsigned int /*tag*/, size_t */*size*/); int der_put_octet_string ( unsigned char */*p*/, size_t /*len*/, const heim_octet_string */*data*/, size_t */*size*/); int der_put_oid ( unsigned char */*p*/, size_t /*len*/, const heim_oid */*data*/, size_t */*size*/); int der_put_printable_string ( unsigned char */*p*/, size_t /*len*/, const heim_printable_string */*str*/, size_t */*size*/); int der_put_tag ( unsigned char */*p*/, size_t /*len*/, Der_class /*class*/, Der_type /*type*/, unsigned int /*tag*/, size_t */*size*/); int der_put_universal_string ( unsigned char */*p*/, size_t /*len*/, const heim_universal_string */*data*/, size_t */*size*/); int der_put_unsigned ( unsigned char */*p*/, size_t /*len*/, const unsigned */*v*/, size_t */*size*/); int der_put_unsigned64 ( unsigned char */*p*/, size_t /*len*/, const uint64_t */*v*/, size_t */*size*/); int der_put_utctime ( unsigned char */*p*/, size_t /*len*/, const time_t */*data*/, size_t */*size*/); int der_put_utf8string ( unsigned char */*p*/, size_t /*len*/, const heim_utf8_string */*str*/, size_t */*size*/); int der_put_visible_string ( unsigned char */*p*/, size_t /*len*/, const heim_visible_string */*str*/, size_t */*size*/); int encode_heim_any ( unsigned char */*p*/, size_t /*len*/, const heim_any */*data*/, size_t */*size*/); int encode_heim_any_set ( unsigned char */*p*/, size_t /*len*/, const heim_any_set */*data*/, size_t */*size*/); void free_heim_any (heim_any */*data*/); void free_heim_any_set (heim_any_set */*data*/); int heim_any_cmp ( const heim_any_set */*p*/, const heim_any_set */*q*/); size_t length_heim_any (const heim_any */*data*/); size_t length_heim_any_set (const heim_any */*data*/); #ifdef __cplusplus } #endif #endif /* DOXY */ #endif /* __der_protos_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/der.h000066400000000000000000000061501505521762700215410ustar00rootroot00000000000000/* * Copyright (c) 1997 - 2006 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef __DER_H__ #define __DER_H__ #include typedef enum { ASN1_C_UNIV = 0, ASN1_C_APPL = 1, ASN1_C_CONTEXT = 2, ASN1_C_PRIVATE = 3 } Der_class; typedef enum {PRIM = 0, CONS = 1} Der_type; #define MAKE_TAG(CLASS, TYPE, TAG) (((CLASS) << 6) | ((TYPE) << 5) | (TAG)) /* Universal tags */ enum { UT_EndOfContent = 0, UT_Boolean = 1, UT_Integer = 2, UT_BitString = 3, UT_OctetString = 4, UT_Null = 5, UT_OID = 6, UT_Enumerated = 10, UT_UTF8String = 12, UT_Sequence = 16, UT_Set = 17, UT_PrintableString = 19, UT_IA5String = 22, UT_UTCTime = 23, UT_GeneralizedTime = 24, UT_UniversalString = 25, UT_VisibleString = 26, UT_GeneralString = 27, UT_BMPString = 30, /* unsupported types */ UT_ObjectDescriptor = 7, UT_External = 8, UT_Real = 9, UT_EmbeddedPDV = 11, UT_RelativeOID = 13, UT_NumericString = 18, UT_TeletexString = 20, UT_VideotexString = 21, UT_GraphicString = 25 }; #define ASN1_INDEFINITE 0xdce0deed typedef struct heim_der_time_t { time_t dt_sec; unsigned long dt_nsec; } heim_der_time_t; typedef struct heim_ber_time_t { time_t bt_sec; unsigned bt_nsec; int bt_zone; } heim_ber_time_t; struct asn1_template; #include int _heim_fix_dce(size_t reallen, size_t *len); int _heim_der_set_sort(const void *, const void *); int _heim_time2generalizedtime (time_t, heim_octet_string *, int); #endif /* __DER_H__ */ pykrb5-0.8.0/build_helpers/heimdal/include/digest_asn1.h000066400000000000000000000422171505521762700231740ustar00rootroot00000000000000/* Generated from ./digest.asn1 */ /* Do not edit */ #ifndef __digest_asn1_h__ #define __digest_asn1_h__ #include #include #ifndef __asn1_common_definitions__ #define __asn1_common_definitions__ #ifndef __HEIM_BASE_DATA__ #define __HEIM_BASE_DATA__ 1 struct heim_base_data { size_t length; void *data; }; typedef struct heim_base_data heim_octet_string; #endif typedef struct heim_integer { size_t length; void *data; int negative; } heim_integer; typedef char *heim_general_string; typedef char *heim_utf8_string; typedef struct heim_base_data heim_printable_string; typedef struct heim_base_data heim_ia5_string; typedef struct heim_bmp_string { size_t length; uint16_t *data; } heim_bmp_string; typedef struct heim_universal_string { size_t length; uint32_t *data; } heim_universal_string; typedef char *heim_visible_string; typedef struct heim_oid { size_t length; unsigned *components; } heim_oid; typedef struct heim_bit_string { size_t length; void *data; } heim_bit_string; typedef struct heim_base_data heim_any; typedef struct heim_base_data heim_any_set; #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \ do { \ (BL) = length_##T((S)); \ (B) = malloc((BL)); \ if((B) == NULL) { \ (R) = ENOMEM; \ } else { \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (S), (L)); \ if((R) != 0) { \ free((B)); \ (B) = NULL; \ } \ } \ } while (0) #ifdef _WIN32 #ifndef ASN1_LIB #define ASN1EXP __declspec(dllimport) #else #define ASN1EXP #endif #define ASN1CALL __stdcall #else #define ASN1EXP #define ASN1CALL #endif struct units; #endif #include /* DigestTypes ::= BIT STRING { ntlm-v1(0), ntlm-v1-session(1), ntlm-v2(2), digest-md5(3), chap-md5(4), ms-chap-v2(5) } */ typedef struct DigestTypes { unsigned int ntlm_v1:1; unsigned int ntlm_v1_session:1; unsigned int ntlm_v2:1; unsigned int digest_md5:1; unsigned int chap_md5:1; unsigned int ms_chap_v2:1; unsigned int _unused6:1; unsigned int _unused7:1; unsigned int _unused8:1; unsigned int _unused9:1; unsigned int _unused10:1; unsigned int _unused11:1; unsigned int _unused12:1; unsigned int _unused13:1; unsigned int _unused14:1; unsigned int _unused15:1; unsigned int _unused16:1; unsigned int _unused17:1; unsigned int _unused18:1; unsigned int _unused19:1; unsigned int _unused20:1; unsigned int _unused21:1; unsigned int _unused22:1; unsigned int _unused23:1; unsigned int _unused24:1; unsigned int _unused25:1; unsigned int _unused26:1; unsigned int _unused27:1; unsigned int _unused28:1; unsigned int _unused29:1; unsigned int _unused30:1; unsigned int _unused31:1; } DigestTypes; unsigned DigestTypes2int(DigestTypes); DigestTypes int2DigestTypes(unsigned); const struct units * asn1_DigestTypes_units(void); ASN1EXP int ASN1CALL decode_DigestTypes(const unsigned char *, size_t, DigestTypes *, size_t *); ASN1EXP int ASN1CALL encode_DigestTypes(unsigned char *, size_t, const DigestTypes *, size_t *); ASN1EXP size_t ASN1CALL length_DigestTypes(const DigestTypes *); ASN1EXP int ASN1CALL copy_DigestTypes (const DigestTypes *, DigestTypes *); ASN1EXP void ASN1CALL free_DigestTypes (DigestTypes *); /* DigestInit ::= SEQUENCE { type UTF8String, channel [0] SEQUENCE { cb-type UTF8String, cb-binding UTF8String, } OPTIONAL, hostname [1] UTF8String OPTIONAL, } */ typedef struct DigestInit { heim_utf8_string type; struct DigestInit_channel { heim_utf8_string cb_type; heim_utf8_string cb_binding; } *channel; heim_utf8_string *hostname; } DigestInit; ASN1EXP int ASN1CALL decode_DigestInit(const unsigned char *, size_t, DigestInit *, size_t *); ASN1EXP int ASN1CALL encode_DigestInit(unsigned char *, size_t, const DigestInit *, size_t *); ASN1EXP size_t ASN1CALL length_DigestInit(const DigestInit *); ASN1EXP int ASN1CALL copy_DigestInit (const DigestInit *, DigestInit *); ASN1EXP void ASN1CALL free_DigestInit (DigestInit *); /* DigestInitReply ::= SEQUENCE { nonce UTF8String, opaque UTF8String, identifier [0] UTF8String OPTIONAL, } */ typedef struct DigestInitReply { heim_utf8_string nonce; heim_utf8_string opaque; heim_utf8_string *identifier; } DigestInitReply; ASN1EXP int ASN1CALL decode_DigestInitReply(const unsigned char *, size_t, DigestInitReply *, size_t *); ASN1EXP int ASN1CALL encode_DigestInitReply(unsigned char *, size_t, const DigestInitReply *, size_t *); ASN1EXP size_t ASN1CALL length_DigestInitReply(const DigestInitReply *); ASN1EXP int ASN1CALL copy_DigestInitReply (const DigestInitReply *, DigestInitReply *); ASN1EXP void ASN1CALL free_DigestInitReply (DigestInitReply *); /* DigestRequest ::= SEQUENCE { type UTF8String, digest UTF8String, username UTF8String, responseData UTF8String, authid [0] UTF8String OPTIONAL, authentication-user [1] Principal OPTIONAL, realm [2] UTF8String OPTIONAL, method [3] UTF8String OPTIONAL, uri [4] UTF8String OPTIONAL, serverNonce UTF8String, clientNonce [5] UTF8String OPTIONAL, nonceCount [6] UTF8String OPTIONAL, qop [7] UTF8String OPTIONAL, identifier [8] UTF8String OPTIONAL, hostname [9] UTF8String OPTIONAL, opaque UTF8String, } */ typedef struct DigestRequest { heim_utf8_string type; heim_utf8_string digest; heim_utf8_string username; heim_utf8_string responseData; heim_utf8_string *authid; Principal *authentication_user; heim_utf8_string *realm; heim_utf8_string *method; heim_utf8_string *uri; heim_utf8_string serverNonce; heim_utf8_string *clientNonce; heim_utf8_string *nonceCount; heim_utf8_string *qop; heim_utf8_string *identifier; heim_utf8_string *hostname; heim_utf8_string opaque; } DigestRequest; ASN1EXP int ASN1CALL decode_DigestRequest(const unsigned char *, size_t, DigestRequest *, size_t *); ASN1EXP int ASN1CALL encode_DigestRequest(unsigned char *, size_t, const DigestRequest *, size_t *); ASN1EXP size_t ASN1CALL length_DigestRequest(const DigestRequest *); ASN1EXP int ASN1CALL copy_DigestRequest (const DigestRequest *, DigestRequest *); ASN1EXP void ASN1CALL free_DigestRequest (DigestRequest *); /* DigestError ::= SEQUENCE { reason UTF8String, code INTEGER (-2147483648..2147483647), } */ typedef struct DigestError { heim_utf8_string reason; int code; } DigestError; ASN1EXP int ASN1CALL decode_DigestError(const unsigned char *, size_t, DigestError *, size_t *); ASN1EXP int ASN1CALL encode_DigestError(unsigned char *, size_t, const DigestError *, size_t *); ASN1EXP size_t ASN1CALL length_DigestError(const DigestError *); ASN1EXP int ASN1CALL copy_DigestError (const DigestError *, DigestError *); ASN1EXP void ASN1CALL free_DigestError (DigestError *); /* DigestResponse ::= SEQUENCE { success BOOLEAN, rsp [0] UTF8String OPTIONAL, tickets [1] SEQUENCE OF OCTET STRING OPTIONAL, channel [2] SEQUENCE { cb-type UTF8String, cb-binding UTF8String, } OPTIONAL, session-key [3] OCTET STRING OPTIONAL, } */ typedef struct DigestResponse { int success; heim_utf8_string *rsp; struct DigestResponse_tickets { unsigned int len; heim_octet_string *val; } *tickets; struct DigestResponse_channel { heim_utf8_string cb_type; heim_utf8_string cb_binding; } *channel; heim_octet_string *session_key; } DigestResponse; ASN1EXP int ASN1CALL decode_DigestResponse(const unsigned char *, size_t, DigestResponse *, size_t *); ASN1EXP int ASN1CALL encode_DigestResponse(unsigned char *, size_t, const DigestResponse *, size_t *); ASN1EXP size_t ASN1CALL length_DigestResponse(const DigestResponse *); ASN1EXP int ASN1CALL copy_DigestResponse (const DigestResponse *, DigestResponse *); ASN1EXP void ASN1CALL free_DigestResponse (DigestResponse *); /* NTLMInit ::= SEQUENCE { flags [0] INTEGER (0..4294967295), hostname [1] UTF8String OPTIONAL, domain [1] UTF8String OPTIONAL, } */ typedef struct NTLMInit { unsigned int flags; heim_utf8_string *hostname; heim_utf8_string *domain; } NTLMInit; ASN1EXP int ASN1CALL decode_NTLMInit(const unsigned char *, size_t, NTLMInit *, size_t *); ASN1EXP int ASN1CALL encode_NTLMInit(unsigned char *, size_t, const NTLMInit *, size_t *); ASN1EXP size_t ASN1CALL length_NTLMInit(const NTLMInit *); ASN1EXP int ASN1CALL copy_NTLMInit (const NTLMInit *, NTLMInit *); ASN1EXP void ASN1CALL free_NTLMInit (NTLMInit *); /* NTLMInitReply ::= SEQUENCE { flags [0] INTEGER (0..4294967295), opaque [1] OCTET STRING, targetname [2] UTF8String, challenge [3] OCTET STRING, targetinfo [4] OCTET STRING OPTIONAL, } */ typedef struct NTLMInitReply { unsigned int flags; heim_octet_string opaque; heim_utf8_string targetname; heim_octet_string challenge; heim_octet_string *targetinfo; } NTLMInitReply; ASN1EXP int ASN1CALL decode_NTLMInitReply(const unsigned char *, size_t, NTLMInitReply *, size_t *); ASN1EXP int ASN1CALL encode_NTLMInitReply(unsigned char *, size_t, const NTLMInitReply *, size_t *); ASN1EXP size_t ASN1CALL length_NTLMInitReply(const NTLMInitReply *); ASN1EXP int ASN1CALL copy_NTLMInitReply (const NTLMInitReply *, NTLMInitReply *); ASN1EXP void ASN1CALL free_NTLMInitReply (NTLMInitReply *); /* NTLMRequest ::= SEQUENCE { flags [0] INTEGER (0..4294967295), opaque [1] OCTET STRING, username [2] UTF8String, targetname [3] UTF8String, targetinfo [4] OCTET STRING OPTIONAL, lm [5] OCTET STRING, ntlm [6] OCTET STRING, sessionkey [7] OCTET STRING OPTIONAL, } */ typedef struct NTLMRequest { unsigned int flags; heim_octet_string opaque; heim_utf8_string username; heim_utf8_string targetname; heim_octet_string *targetinfo; heim_octet_string lm; heim_octet_string ntlm; heim_octet_string *sessionkey; } NTLMRequest; ASN1EXP int ASN1CALL decode_NTLMRequest(const unsigned char *, size_t, NTLMRequest *, size_t *); ASN1EXP int ASN1CALL encode_NTLMRequest(unsigned char *, size_t, const NTLMRequest *, size_t *); ASN1EXP size_t ASN1CALL length_NTLMRequest(const NTLMRequest *); ASN1EXP int ASN1CALL copy_NTLMRequest (const NTLMRequest *, NTLMRequest *); ASN1EXP void ASN1CALL free_NTLMRequest (NTLMRequest *); /* NTLMResponse ::= SEQUENCE { success [0] BOOLEAN, flags [1] INTEGER (0..4294967295), sessionkey [2] OCTET STRING OPTIONAL, tickets [3] SEQUENCE OF OCTET STRING OPTIONAL, } */ typedef struct NTLMResponse { int success; unsigned int flags; heim_octet_string *sessionkey; struct NTLMResponse_tickets { unsigned int len; heim_octet_string *val; } *tickets; } NTLMResponse; ASN1EXP int ASN1CALL decode_NTLMResponse(const unsigned char *, size_t, NTLMResponse *, size_t *); ASN1EXP int ASN1CALL encode_NTLMResponse(unsigned char *, size_t, const NTLMResponse *, size_t *); ASN1EXP size_t ASN1CALL length_NTLMResponse(const NTLMResponse *); ASN1EXP int ASN1CALL copy_NTLMResponse (const NTLMResponse *, NTLMResponse *); ASN1EXP void ASN1CALL free_NTLMResponse (NTLMResponse *); /* NTLMRequest2 ::= SEQUENCE { loginUserName [0] UTF8String, loginDomainName [1] UTF8String, flags [2] INTEGER (0..4294967295), lmchallenge [3] OCTET STRING, ntChallengeResponce [4] OCTET STRING, lmChallengeResponce [5] OCTET STRING, } */ typedef struct NTLMRequest2 { heim_utf8_string loginUserName; heim_utf8_string loginDomainName; unsigned int flags; heim_octet_string lmchallenge; heim_octet_string ntChallengeResponce; heim_octet_string lmChallengeResponce; } NTLMRequest2; ASN1EXP int ASN1CALL decode_NTLMRequest2(const unsigned char *, size_t, NTLMRequest2 *, size_t *); ASN1EXP int ASN1CALL encode_NTLMRequest2(unsigned char *, size_t, const NTLMRequest2 *, size_t *); ASN1EXP size_t ASN1CALL length_NTLMRequest2(const NTLMRequest2 *); ASN1EXP int ASN1CALL copy_NTLMRequest2 (const NTLMRequest2 *, NTLMRequest2 *); ASN1EXP void ASN1CALL free_NTLMRequest2 (NTLMRequest2 *); /* NTLMReply ::= SEQUENCE { success [0] BOOLEAN, flags [1] INTEGER (0..4294967295), sessionkey [2] OCTET STRING OPTIONAL, } */ typedef struct NTLMReply { int success; unsigned int flags; heim_octet_string *sessionkey; } NTLMReply; ASN1EXP int ASN1CALL decode_NTLMReply(const unsigned char *, size_t, NTLMReply *, size_t *); ASN1EXP int ASN1CALL encode_NTLMReply(unsigned char *, size_t, const NTLMReply *, size_t *); ASN1EXP size_t ASN1CALL length_NTLMReply(const NTLMReply *); ASN1EXP int ASN1CALL copy_NTLMReply (const NTLMReply *, NTLMReply *); ASN1EXP void ASN1CALL free_NTLMReply (NTLMReply *); /* DigestReqInner ::= CHOICE { init [0] DigestInit, digestRequest [1] DigestRequest, ntlmInit [2] NTLMInit, ntlmRequest [3] NTLMRequest, supportedMechs [4] NULL, } */ typedef struct DigestReqInner { enum DigestReqInner_enum { choice_DigestReqInner_init = 1, choice_DigestReqInner_digestRequest, choice_DigestReqInner_ntlmInit, choice_DigestReqInner_ntlmRequest, choice_DigestReqInner_supportedMechs } element; union { DigestInit init; DigestRequest digestRequest; NTLMInit ntlmInit; NTLMRequest ntlmRequest; int supportedMechs; } u; } DigestReqInner; ASN1EXP int ASN1CALL decode_DigestReqInner(const unsigned char *, size_t, DigestReqInner *, size_t *); ASN1EXP int ASN1CALL encode_DigestReqInner(unsigned char *, size_t, const DigestReqInner *, size_t *); ASN1EXP size_t ASN1CALL length_DigestReqInner(const DigestReqInner *); ASN1EXP int ASN1CALL copy_DigestReqInner (const DigestReqInner *, DigestReqInner *); ASN1EXP void ASN1CALL free_DigestReqInner (DigestReqInner *); /* DigestREQ ::= [APPLICATION 128] SEQUENCE { apReq [0] OCTET STRING, innerReq [1] EncryptedData, } */ typedef struct DigestREQ { heim_octet_string apReq; EncryptedData innerReq; } DigestREQ; ASN1EXP int ASN1CALL decode_DigestREQ(const unsigned char *, size_t, DigestREQ *, size_t *); ASN1EXP int ASN1CALL encode_DigestREQ(unsigned char *, size_t, const DigestREQ *, size_t *); ASN1EXP size_t ASN1CALL length_DigestREQ(const DigestREQ *); ASN1EXP int ASN1CALL copy_DigestREQ (const DigestREQ *, DigestREQ *); ASN1EXP void ASN1CALL free_DigestREQ (DigestREQ *); /* DigestRepInner ::= CHOICE { error [0] DigestError, initReply [1] DigestInitReply, response [2] DigestResponse, ntlmInitReply [3] NTLMInitReply, ntlmResponse [4] NTLMResponse, supportedMechs [5] DigestTypes, ..., } */ typedef struct DigestRepInner { enum DigestRepInner_enum { choice_DigestRepInner_asn1_ellipsis = 0, choice_DigestRepInner_error, choice_DigestRepInner_initReply, choice_DigestRepInner_response, choice_DigestRepInner_ntlmInitReply, choice_DigestRepInner_ntlmResponse, choice_DigestRepInner_supportedMechs /* ... */ } element; union { DigestError error; DigestInitReply initReply; DigestResponse response; NTLMInitReply ntlmInitReply; NTLMResponse ntlmResponse; DigestTypes supportedMechs; heim_octet_string asn1_ellipsis; } u; } DigestRepInner; ASN1EXP int ASN1CALL decode_DigestRepInner(const unsigned char *, size_t, DigestRepInner *, size_t *); ASN1EXP int ASN1CALL encode_DigestRepInner(unsigned char *, size_t, const DigestRepInner *, size_t *); ASN1EXP size_t ASN1CALL length_DigestRepInner(const DigestRepInner *); ASN1EXP int ASN1CALL copy_DigestRepInner (const DigestRepInner *, DigestRepInner *); ASN1EXP void ASN1CALL free_DigestRepInner (DigestRepInner *); /* DigestREP ::= [APPLICATION 129] SEQUENCE { apRep [0] OCTET STRING, innerRep [1] EncryptedData, } */ typedef struct DigestREP { heim_octet_string apRep; EncryptedData innerRep; } DigestREP; ASN1EXP int ASN1CALL decode_DigestREP(const unsigned char *, size_t, DigestREP *, size_t *); ASN1EXP int ASN1CALL encode_DigestREP(unsigned char *, size_t, const DigestREP *, size_t *); ASN1EXP size_t ASN1CALL length_DigestREP(const DigestREP *); ASN1EXP int ASN1CALL copy_DigestREP (const DigestREP *, DigestREP *); ASN1EXP void ASN1CALL free_DigestREP (DigestREP *); #endif /* __digest_asn1_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/getarg.h000066400000000000000000000062351505521762700222440ustar00rootroot00000000000000/* * Copyright (c) 1997 - 2002 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef __GETARG_H__ #define __GETARG_H__ #include #ifndef ROKEN_LIB_FUNCTION #ifdef _WIN32 #define ROKEN_LIB_FUNCTION #define ROKEN_LIB_CALL __cdecl #else #define ROKEN_LIB_FUNCTION #define ROKEN_LIB_CALL #endif #endif struct getargs{ const char *long_name; char short_name; enum { arg_integer, arg_string, arg_flag, arg_negative_flag, arg_strings, arg_double, arg_collect, arg_counter } type; void *value; const char *help; const char *arg_help; }; enum { ARG_ERR_NO_MATCH = 1, ARG_ERR_BAD_ARG, ARG_ERR_NO_ARG }; typedef struct getarg_strings { int num_strings; char **strings; } getarg_strings; typedef int (*getarg_collect_func)(int short_opt, int argc, char **argv, int *goptind, int *goptarg, void *data); typedef struct getarg_collect_info { getarg_collect_func func; void *data; } getarg_collect_info; ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL getarg(struct getargs *args, size_t num_args, int argc, char **argv, int *goptind); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL arg_printusage (struct getargs *args, size_t num_args, const char *progname, const char *extra_string); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL arg_printusage_i18n (struct getargs *args, size_t num_args, const char *usage, const char *progname, const char *extra_string, char *(*i18n)(const char *)); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL free_getarg_strings (getarg_strings *); #endif /* __GETARG_H__ */ pykrb5-0.8.0/build_helpers/heimdal/include/gssapi.h000066400000000000000000000032731505521762700222600ustar00rootroot00000000000000/* * Copyright (c) 2006 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef GSSAPI_H_ #define GSSAPI_H_ #include #endif pykrb5-0.8.0/build_helpers/heimdal/include/gssapi/000077500000000000000000000000001505521762700221025ustar00rootroot00000000000000pykrb5-0.8.0/build_helpers/heimdal/include/gssapi/gkrb5_err.h000066400000000000000000000022051505521762700241340ustar00rootroot00000000000000/* Generated from ./krb5/gkrb5_err.et */ /* $Id$ */ #ifndef __gkrb5_err_h__ #define __gkrb5_err_h__ struct et_list; void initialize_gk5_error_table_r(struct et_list **); void initialize_gk5_error_table(void); #define init_gk5_err_tbl initialize_gk5_error_table typedef enum gk5_error_number{ GSS_KRB5_S_G_BAD_SERVICE_NAME = 35224064, GSS_KRB5_S_G_BAD_STRING_UID = 35224065, GSS_KRB5_S_G_NOUSER = 35224066, GSS_KRB5_S_G_VALIDATE_FAILED = 35224067, GSS_KRB5_S_G_BUFFER_ALLOC = 35224068, GSS_KRB5_S_G_BAD_MSG_CTX = 35224069, GSS_KRB5_S_G_WRONG_SIZE = 35224070, GSS_KRB5_S_G_BAD_USAGE = 35224071, GSS_KRB5_S_G_UNKNOWN_QOP = 35224072, GSS_KRB5_S_KG_CCACHE_NOMATCH = 35224192, GSS_KRB5_S_KG_KEYTAB_NOMATCH = 35224193, GSS_KRB5_S_KG_TGT_MISSING = 35224194, GSS_KRB5_S_KG_NO_SUBKEY = 35224195, GSS_KRB5_S_KG_CONTEXT_ESTABLISHED = 35224196, GSS_KRB5_S_KG_BAD_SIGN_TYPE = 35224197, GSS_KRB5_S_KG_BAD_LENGTH = 35224198, GSS_KRB5_S_KG_CTX_INCOMPLETE = 35224199, GSS_KRB5_S_KG_INPUT_TOO_LONG = 35224200 } gk5_error_number; #define ERROR_TABLE_BASE_gk5 35224064 #define COM_ERR_BINDDOMAIN_gk5 "heim_com_err35224064" #endif /* __gkrb5_err_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/gssapi/gssapi.h000066400000000000000000001122731505521762700235470ustar00rootroot00000000000000/* * Copyright (c) 1997 - 2007 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef GSSAPI_GSSAPI_H_ #define GSSAPI_GSSAPI_H_ /* * First, include stddef.h to get size_t defined. */ #include #include #ifndef BUILD_GSSAPI_LIB #if defined(_WIN32) #define GSSAPI_LIB_FUNCTION __declspec(dllimport) #define GSSAPI_LIB_CALL __stdcall #define GSSAPI_LIB_VARIABLE __declspec(dllimport) #else #define GSSAPI_LIB_FUNCTION #define GSSAPI_LIB_CALL #define GSSAPI_LIB_VARIABLE #endif #endif #ifndef GSSAPI_DEPRECATED_FUNCTION #if defined(__GNUC__) && ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1 ))) #define GSSAPI_DEPRECATED_FUNCTION(X) __attribute__((deprecated)) #else #define GSSAPI_DEPRECATED_FUNCTION(X) #endif #endif /* Compatiblity with MIT Kerberos on the Mac */ #if defined(__APPLE__) && (defined(__ppc__) || defined(__ppc64__) || defined(__i386__) || defined(__x86_64__)) #pragma pack(push,2) #endif #ifdef __cplusplus #define GSSAPI_CPP_START extern "C" { #define GSSAPI_CPP_END } #else #define GSSAPI_CPP_START #define GSSAPI_CPP_END #endif #ifdef _WIN32 #define GSSAPI_CALLCONV __stdcall #else #define GSSAPI_CALLCONV #endif /* * Now define the three implementation-dependent types. */ typedef uint32_t OM_uint32; typedef uint64_t OM_uint64; typedef uint32_t gss_uint32; struct gss_name_t_desc_struct; typedef struct gss_name_t_desc_struct *gss_name_t; typedef const struct gss_name_t_desc_struct *gss_const_name_t; struct gss_ctx_id_t_desc_struct; typedef struct gss_ctx_id_t_desc_struct *gss_ctx_id_t; typedef const struct gss_ctx_id_t_desc_struct *gss_const_ctx_id_t; typedef struct gss_OID_desc_struct { OM_uint32 length; void *elements; } gss_OID_desc, *gss_OID; typedef const gss_OID_desc * gss_const_OID; typedef struct gss_OID_set_desc_struct { size_t count; gss_OID elements; } gss_OID_set_desc, *gss_OID_set; typedef const gss_OID_set_desc * gss_const_OID_set; typedef int gss_cred_usage_t; struct gss_cred_id_t_desc_struct; typedef struct gss_cred_id_t_desc_struct *gss_cred_id_t; typedef const struct gss_cred_id_t_desc_struct *gss_const_cred_id_t; typedef struct gss_buffer_desc_struct { size_t length; void *value; } gss_buffer_desc, *gss_buffer_t; typedef const gss_buffer_desc * gss_const_buffer_t; typedef struct gss_channel_bindings_struct { OM_uint32 initiator_addrtype; gss_buffer_desc initiator_address; OM_uint32 acceptor_addrtype; gss_buffer_desc acceptor_address; gss_buffer_desc application_data; } *gss_channel_bindings_t; typedef const struct gss_channel_bindings_struct *gss_const_channel_bindings_t; /* GGF extension data types */ typedef struct gss_buffer_set_desc_struct { size_t count; gss_buffer_desc *elements; } gss_buffer_set_desc, *gss_buffer_set_t; typedef struct gss_iov_buffer_desc_struct { OM_uint32 type; gss_buffer_desc buffer; } gss_iov_buffer_desc, *gss_iov_buffer_t; /* * For now, define a QOP-type as an OM_uint32 */ typedef OM_uint32 gss_qop_t; /* * Flag bits for context-level services. */ #define GSS_C_DELEG_FLAG 1 #define GSS_C_MUTUAL_FLAG 2 #define GSS_C_REPLAY_FLAG 4 #define GSS_C_SEQUENCE_FLAG 8 #define GSS_C_CONF_FLAG 16 #define GSS_C_INTEG_FLAG 32 #define GSS_C_ANON_FLAG 64 #define GSS_C_PROT_READY_FLAG 128 #define GSS_C_TRANS_FLAG 256 #define GSS_C_DCE_STYLE 4096 #define GSS_C_IDENTIFY_FLAG 8192 #define GSS_C_EXTENDED_ERROR_FLAG 16384 #define GSS_C_DELEG_POLICY_FLAG 32768 /* * Credential usage options */ #define GSS_C_BOTH 0 #define GSS_C_INITIATE 1 #define GSS_C_ACCEPT 2 /* * Status code types for gss_display_status */ #define GSS_C_GSS_CODE 1 #define GSS_C_MECH_CODE 2 /* * The constant definitions for channel-bindings address families */ #define GSS_C_AF_UNSPEC 0 #define GSS_C_AF_LOCAL 1 #define GSS_C_AF_INET 2 #define GSS_C_AF_IMPLINK 3 #define GSS_C_AF_PUP 4 #define GSS_C_AF_CHAOS 5 #define GSS_C_AF_NS 6 #define GSS_C_AF_NBS 7 #define GSS_C_AF_ECMA 8 #define GSS_C_AF_DATAKIT 9 #define GSS_C_AF_CCITT 10 #define GSS_C_AF_SNA 11 #define GSS_C_AF_DECnet 12 #define GSS_C_AF_DLI 13 #define GSS_C_AF_LAT 14 #define GSS_C_AF_HYLINK 15 #define GSS_C_AF_APPLETALK 16 #define GSS_C_AF_BSC 17 #define GSS_C_AF_DSS 18 #define GSS_C_AF_OSI 19 #define GSS_C_AF_X25 21 #define GSS_C_AF_INET6 24 #define GSS_C_AF_NULLADDR 255 /* * Various Null values */ #define GSS_C_NO_NAME ((gss_name_t) 0) #define GSS_C_NO_BUFFER ((gss_buffer_t) 0) #define GSS_C_NO_BUFFER_SET ((gss_buffer_set_t) 0) #define GSS_C_NO_OID ((gss_OID) 0) #define GSS_C_NO_OID_SET ((gss_OID_set) 0) #define GSS_C_NO_CONTEXT ((gss_ctx_id_t) 0) #define GSS_C_NO_CREDENTIAL ((gss_cred_id_t) 0) #define GSS_C_NO_CHANNEL_BINDINGS ((gss_channel_bindings_t) 0) #define GSS_C_EMPTY_BUFFER {0, NULL} #define GSS_C_NO_IOV_BUFFER ((gss_iov_buffer_t)0) /* * Some alternate names for a couple of the above * values. These are defined for V1 compatibility. */ #define GSS_C_NULL_OID GSS_C_NO_OID #define GSS_C_NULL_OID_SET GSS_C_NO_OID_SET /* * Define the default Quality of Protection for per-message * services. Note that an implementation that offers multiple * levels of QOP may define GSS_C_QOP_DEFAULT to be either zero * (as done here) to mean "default protection", or to a specific * explicit QOP value. However, a value of 0 should always be * interpreted by a GSSAPI implementation as a request for the * default protection level. */ #define GSS_C_QOP_DEFAULT 0 #define GSS_KRB5_CONF_C_QOP_DES 0x0100 #define GSS_KRB5_CONF_C_QOP_DES3_KD 0x0200 /* * Expiration time of 2^32-1 seconds means infinite lifetime for a * credential or security context */ #define GSS_C_INDEFINITE 0xfffffffful /* * Type of gss_wrap_iov()/gss_unwrap_iov(). */ #define GSS_IOV_BUFFER_TYPE_EMPTY 0 #define GSS_IOV_BUFFER_TYPE_DATA 1 #define GSS_IOV_BUFFER_TYPE_HEADER 2 #define GSS_IOV_BUFFER_TYPE_MECH_PARAMS 3 #define GSS_IOV_BUFFER_TYPE_TRAILER 7 #define GSS_IOV_BUFFER_TYPE_PADDING 9 #define GSS_IOV_BUFFER_TYPE_STREAM 10 #define GSS_IOV_BUFFER_TYPE_SIGN_ONLY 11 #define GSS_IOV_BUFFER_TYPE_FLAG_MASK 0xffff0000 #define GSS_IOV_BUFFER_FLAG_ALLOCATE 0x00010000 #define GSS_IOV_BUFFER_FLAG_ALLOCATED 0x00020000 #define GSS_IOV_BUFFER_TYPE_FLAG_ALLOCATE 0x00010000 /* old name */ #define GSS_IOV_BUFFER_TYPE_FLAG_ALLOCATED 0x00020000 /* old name */ #define GSS_IOV_BUFFER_TYPE(_t) ((_t) & ~GSS_IOV_BUFFER_TYPE_FLAG_MASK) #define GSS_IOV_BUFFER_FLAGS(_t) ((_t) & GSS_IOV_BUFFER_TYPE_FLAG_MASK) GSSAPI_CPP_START #include /* * The implementation must reserve static storage for a * gss_OID_desc object containing the value * {10, (void *)"\x2a\x86\x48\x86\xf7\x12" * "\x01\x02\x01\x01"}, * corresponding to an object-identifier value of * {iso(1) member-body(2) United States(840) mit(113554) * infosys(1) gssapi(2) generic(1) user_name(1)}. The constant * GSS_C_NT_USER_NAME should be initialized to point * to that gss_OID_desc. */ extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_nt_user_name_oid_desc; #define GSS_C_NT_USER_NAME (&__gss_c_nt_user_name_oid_desc) /* * The implementation must reserve static storage for a * gss_OID_desc object containing the value * {10, (void *)"\x2a\x86\x48\x86\xf7\x12" * "\x01\x02\x01\x02"}, * corresponding to an object-identifier value of * {iso(1) member-body(2) United States(840) mit(113554) * infosys(1) gssapi(2) generic(1) machine_uid_name(2)}. * The constant GSS_C_NT_MACHINE_UID_NAME should be * initialized to point to that gss_OID_desc. */ extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_nt_machine_uid_name_oid_desc; #define GSS_C_NT_MACHINE_UID_NAME (&__gss_c_nt_machine_uid_name_oid_desc) /* * The implementation must reserve static storage for a * gss_OID_desc object containing the value * {10, (void *)"\x2a\x86\x48\x86\xf7\x12" * "\x01\x02\x01\x03"}, * corresponding to an object-identifier value of * {iso(1) member-body(2) United States(840) mit(113554) * infosys(1) gssapi(2) generic(1) string_uid_name(3)}. * The constant GSS_C_NT_STRING_UID_NAME should be * initialized to point to that gss_OID_desc. */ extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_nt_string_uid_name_oid_desc; #define GSS_C_NT_STRING_UID_NAME (&__gss_c_nt_string_uid_name_oid_desc) /* * The implementation must reserve static storage for a * gss_OID_desc object containing the value * {6, (void *)"\x2b\x06\x01\x05\x06\x02"}, * corresponding to an object-identifier value of * {iso(1) org(3) dod(6) internet(1) security(5) * nametypes(6) gss-host-based-services(2)). The constant * GSS_C_NT_HOSTBASED_SERVICE_X should be initialized to point * to that gss_OID_desc. This is a deprecated OID value, and * implementations wishing to support hostbased-service names * should instead use the GSS_C_NT_HOSTBASED_SERVICE OID, * defined below, to identify such names; * GSS_C_NT_HOSTBASED_SERVICE_X should be accepted a synonym * for GSS_C_NT_HOSTBASED_SERVICE when presented as an input * parameter, but should not be emitted by GSS-API * implementations */ extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_nt_hostbased_service_x_oid_desc; #define GSS_C_NT_HOSTBASED_SERVICE_X (&__gss_c_nt_hostbased_service_x_oid_desc) /* * The implementation must reserve static storage for a * gss_OID_desc object containing the value * {10, (void *)"\x2a\x86\x48\x86\xf7\x12" * "\x01\x02\x01\x04"}, corresponding to an * object-identifier value of {iso(1) member-body(2) * Unites States(840) mit(113554) infosys(1) gssapi(2) * generic(1) service_name(4)}. The constant * GSS_C_NT_HOSTBASED_SERVICE should be initialized * to point to that gss_OID_desc. */ extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_nt_hostbased_service_oid_desc; #define GSS_C_NT_HOSTBASED_SERVICE (&__gss_c_nt_hostbased_service_oid_desc) /* * The implementation must reserve static storage for a * gss_OID_desc object containing the value * {6, (void *)"\x2b\x06\01\x05\x06\x03"}, * corresponding to an object identifier value of * {1(iso), 3(org), 6(dod), 1(internet), 5(security), * 6(nametypes), 3(gss-anonymous-name)}. The constant * and GSS_C_NT_ANONYMOUS should be initialized to point * to that gss_OID_desc. */ extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_nt_anonymous_oid_desc; #define GSS_C_NT_ANONYMOUS (&__gss_c_nt_anonymous_oid_desc) /* * The implementation must reserve static storage for a * gss_OID_desc object containing the value * {6, (void *)"\x2b\x06\x01\x05\x06\x04"}, * corresponding to an object-identifier value of * {1(iso), 3(org), 6(dod), 1(internet), 5(security), * 6(nametypes), 4(gss-api-exported-name)}. The constant * GSS_C_NT_EXPORT_NAME should be initialized to point * to that gss_OID_desc. */ extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_nt_export_name_oid_desc; #define GSS_C_NT_EXPORT_NAME (&__gss_c_nt_export_name_oid_desc) /* Major status codes */ #define GSS_S_COMPLETE 0 /* * Some "helper" definitions to make the status code macros obvious. */ #define GSS_C_CALLING_ERROR_OFFSET 24 #define GSS_C_ROUTINE_ERROR_OFFSET 16 #define GSS_C_SUPPLEMENTARY_OFFSET 0 #define GSS_C_CALLING_ERROR_MASK 0377ul #define GSS_C_ROUTINE_ERROR_MASK 0377ul #define GSS_C_SUPPLEMENTARY_MASK 0177777ul /* * The macros that test status codes for error conditions. * Note that the GSS_ERROR() macro has changed slightly from * the V1 GSSAPI so that it now evaluates its argument * only once. */ #define GSS_CALLING_ERROR(x) \ (x & (GSS_C_CALLING_ERROR_MASK << GSS_C_CALLING_ERROR_OFFSET)) #define GSS_ROUTINE_ERROR(x) \ (x & (GSS_C_ROUTINE_ERROR_MASK << GSS_C_ROUTINE_ERROR_OFFSET)) #define GSS_SUPPLEMENTARY_INFO(x) \ (x & (GSS_C_SUPPLEMENTARY_MASK << GSS_C_SUPPLEMENTARY_OFFSET)) #define GSS_ERROR(x) \ (x & ((GSS_C_CALLING_ERROR_MASK << GSS_C_CALLING_ERROR_OFFSET) | \ (GSS_C_ROUTINE_ERROR_MASK << GSS_C_ROUTINE_ERROR_OFFSET))) /* * Now the actual status code definitions */ /* * Calling errors: */ #define GSS_S_CALL_INACCESSIBLE_READ \ (1ul << GSS_C_CALLING_ERROR_OFFSET) #define GSS_S_CALL_INACCESSIBLE_WRITE \ (2ul << GSS_C_CALLING_ERROR_OFFSET) #define GSS_S_CALL_BAD_STRUCTURE \ (3ul << GSS_C_CALLING_ERROR_OFFSET) /* * Routine errors: */ #define GSS_S_BAD_MECH (1ul << GSS_C_ROUTINE_ERROR_OFFSET) #define GSS_S_BAD_NAME (2ul << GSS_C_ROUTINE_ERROR_OFFSET) #define GSS_S_BAD_NAMETYPE (3ul << GSS_C_ROUTINE_ERROR_OFFSET) #define GSS_S_BAD_BINDINGS (4ul << GSS_C_ROUTINE_ERROR_OFFSET) #define GSS_S_BAD_STATUS (5ul << GSS_C_ROUTINE_ERROR_OFFSET) #define GSS_S_BAD_SIG (6ul << GSS_C_ROUTINE_ERROR_OFFSET) #define GSS_S_BAD_MIC GSS_S_BAD_SIG #define GSS_S_NO_CRED (7ul << GSS_C_ROUTINE_ERROR_OFFSET) #define GSS_S_NO_CONTEXT (8ul << GSS_C_ROUTINE_ERROR_OFFSET) #define GSS_S_DEFECTIVE_TOKEN (9ul << GSS_C_ROUTINE_ERROR_OFFSET) #define GSS_S_DEFECTIVE_CREDENTIAL (10ul << GSS_C_ROUTINE_ERROR_OFFSET) #define GSS_S_CREDENTIALS_EXPIRED (11ul << GSS_C_ROUTINE_ERROR_OFFSET) #define GSS_S_CONTEXT_EXPIRED (12ul << GSS_C_ROUTINE_ERROR_OFFSET) #define GSS_S_FAILURE (13ul << GSS_C_ROUTINE_ERROR_OFFSET) #define GSS_S_BAD_QOP (14ul << GSS_C_ROUTINE_ERROR_OFFSET) #define GSS_S_UNAUTHORIZED (15ul << GSS_C_ROUTINE_ERROR_OFFSET) #define GSS_S_UNAVAILABLE (16ul << GSS_C_ROUTINE_ERROR_OFFSET) #define GSS_S_DUPLICATE_ELEMENT (17ul << GSS_C_ROUTINE_ERROR_OFFSET) #define GSS_S_NAME_NOT_MN (18ul << GSS_C_ROUTINE_ERROR_OFFSET) #define GSS_S_BAD_MECH_ATTR (19ul << GSS_C_ROUTINE_ERROR_OFFSET) /* * Apparently awating spec fix. */ #define GSS_S_CRED_UNAVAIL GSS_S_FAILURE /* * Supplementary info bits: */ #define GSS_S_CONTINUE_NEEDED (1ul << (GSS_C_SUPPLEMENTARY_OFFSET + 0)) #define GSS_S_DUPLICATE_TOKEN (1ul << (GSS_C_SUPPLEMENTARY_OFFSET + 1)) #define GSS_S_OLD_TOKEN (1ul << (GSS_C_SUPPLEMENTARY_OFFSET + 2)) #define GSS_S_UNSEQ_TOKEN (1ul << (GSS_C_SUPPLEMENTARY_OFFSET + 3)) #define GSS_S_GAP_TOKEN (1ul << (GSS_C_SUPPLEMENTARY_OFFSET + 4)) /* * Finally, function prototypes for the GSS-API routines. */ #define GSS_C_OPTION_MASK 0xffff #define GSS_C_CRED_NO_UI 0x10000 GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_acquire_cred (OM_uint32 * /*minor_status*/, gss_const_name_t /*desired_name*/, OM_uint32 /*time_req*/, const gss_OID_set /*desired_mechs*/, gss_cred_usage_t /*cred_usage*/, gss_cred_id_t * /*output_cred_handle*/, gss_OID_set * /*actual_mechs*/, OM_uint32 * /*time_rec*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_release_cred (OM_uint32 * /*minor_status*/, gss_cred_id_t * /*cred_handle*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_init_sec_context (OM_uint32 * /*minor_status*/, gss_const_cred_id_t /*initiator_cred_handle*/, gss_ctx_id_t * /*context_handle*/, gss_const_name_t /*target_name*/, const gss_OID /*mech_type*/, OM_uint32 /*req_flags*/, OM_uint32 /*time_req*/, const gss_channel_bindings_t /*input_chan_bindings*/, const gss_buffer_t /*input_token*/, gss_OID * /*actual_mech_type*/, gss_buffer_t /*output_token*/, OM_uint32 * /*ret_flags*/, OM_uint32 * /*time_rec*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_accept_sec_context (OM_uint32 * /*minor_status*/, gss_ctx_id_t * /*context_handle*/, gss_const_cred_id_t /*acceptor_cred_handle*/, const gss_buffer_t /*input_token_buffer*/, const gss_channel_bindings_t /*input_chan_bindings*/, gss_name_t * /*src_name*/, gss_OID * /*mech_type*/, gss_buffer_t /*output_token*/, OM_uint32 * /*ret_flags*/, OM_uint32 * /*time_rec*/, gss_cred_id_t * /*delegated_cred_handle*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_process_context_token (OM_uint32 * /*minor_status*/, gss_const_ctx_id_t /*context_handle*/, const gss_buffer_t /*token_buffer*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_delete_sec_context (OM_uint32 * /*minor_status*/, gss_ctx_id_t * /*context_handle*/, gss_buffer_t /*output_token*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_context_time (OM_uint32 * /*minor_status*/, gss_const_ctx_id_t /*context_handle*/, OM_uint32 * /*time_rec*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_get_mic (OM_uint32 * /*minor_status*/, gss_const_ctx_id_t /*context_handle*/, gss_qop_t /*qop_req*/, const gss_buffer_t /*message_buffer*/, gss_buffer_t /*message_token*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_verify_mic (OM_uint32 * /*minor_status*/, gss_const_ctx_id_t /*context_handle*/, const gss_buffer_t /*message_buffer*/, const gss_buffer_t /*token_buffer*/, gss_qop_t * /*qop_state*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_wrap (OM_uint32 * /*minor_status*/, gss_const_ctx_id_t /*context_handle*/, int /*conf_req_flag*/, gss_qop_t /*qop_req*/, const gss_buffer_t /*input_message_buffer*/, int * /*conf_state*/, gss_buffer_t /*output_message_buffer*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_unwrap (OM_uint32 * /*minor_status*/, gss_const_ctx_id_t /*context_handle*/, const gss_buffer_t /*input_message_buffer*/, gss_buffer_t /*output_message_buffer*/, int * /*conf_state*/, gss_qop_t * /*qop_state*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_display_status (OM_uint32 * /*minor_status*/, OM_uint32 /*status_value*/, int /*status_type*/, const gss_OID /*mech_type*/, OM_uint32 * /*message_context*/, gss_buffer_t /*status_string*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_indicate_mechs (OM_uint32 * /*minor_status*/, gss_OID_set * /*mech_set*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_compare_name (OM_uint32 * /*minor_status*/, gss_const_name_t /*name1*/, gss_const_name_t /*name2*/, int * /*name_equal*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_display_name (OM_uint32 * /*minor_status*/, gss_const_name_t /*input_name*/, gss_buffer_t /*output_name_buffer*/, gss_OID * /*output_name_type*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_import_name (OM_uint32 * /*minor_status*/, const gss_buffer_t /*input_name_buffer*/, const gss_OID /*input_name_type*/, gss_name_t * /*output_name*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_export_name (OM_uint32 * /*minor_status*/, gss_const_name_t /*input_name*/, gss_buffer_t /*exported_name*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_release_name (OM_uint32 * /*minor_status*/, gss_name_t * /*input_name*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_release_buffer (OM_uint32 * /*minor_status*/, gss_buffer_t /*buffer*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_release_oid_set (OM_uint32 * /*minor_status*/, gss_OID_set * /*set*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_inquire_cred (OM_uint32 * /*minor_status*/, gss_const_cred_id_t /*cred_handle*/, gss_name_t * /*name*/, OM_uint32 * /*lifetime*/, gss_cred_usage_t * /*cred_usage*/, gss_OID_set * /*mechanisms*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_inquire_context ( OM_uint32 * /*minor_status*/, gss_const_ctx_id_t /*context_handle*/, gss_name_t * /*src_name*/, gss_name_t * /*targ_name*/, OM_uint32 * /*lifetime_rec*/, gss_OID * /*mech_type*/, OM_uint32 * /*ctx_flags*/, int * /*locally_initiated*/, int * /*open_context*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_wrap_size_limit ( OM_uint32 * /*minor_status*/, gss_const_ctx_id_t /*context_handle*/, int /*conf_req_flag*/, gss_qop_t /*qop_req*/, OM_uint32 /*req_output_size*/, OM_uint32 * /*max_input_size*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_add_cred ( OM_uint32 * /*minor_status*/, gss_const_cred_id_t /*input_cred_handle*/, gss_const_name_t /*desired_name*/, const gss_OID /*desired_mech*/, gss_cred_usage_t /*cred_usage*/, OM_uint32 /*initiator_time_req*/, OM_uint32 /*acceptor_time_req*/, gss_cred_id_t * /*output_cred_handle*/, gss_OID_set * /*actual_mechs*/, OM_uint32 * /*initiator_time_rec*/, OM_uint32 * /*acceptor_time_rec*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_inquire_cred_by_mech ( OM_uint32 * /*minor_status*/, gss_const_cred_id_t /*cred_handle*/, const gss_OID /*mech_type*/, gss_name_t * /*name*/, OM_uint32 * /*initiator_lifetime*/, OM_uint32 * /*acceptor_lifetime*/, gss_cred_usage_t * /*cred_usage*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_export_sec_context ( OM_uint32 * /*minor_status*/, gss_ctx_id_t * /*context_handle*/, gss_buffer_t /*interprocess_token*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_import_sec_context ( OM_uint32 * /*minor_status*/, const gss_buffer_t /*interprocess_token*/, gss_ctx_id_t * /*context_handle*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_create_empty_oid_set ( OM_uint32 * /*minor_status*/, gss_OID_set * /*oid_set*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_add_oid_set_member ( OM_uint32 * /*minor_status*/, const gss_OID /*member_oid*/, gss_OID_set * /*oid_set*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_test_oid_set_member ( OM_uint32 * /*minor_status*/, const gss_OID /*member*/, const gss_OID_set /*set*/, int * /*present*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_inquire_names_for_mech ( OM_uint32 * /*minor_status*/, const gss_OID /*mechanism*/, gss_OID_set * /*name_types*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_inquire_mechs_for_name ( OM_uint32 * /*minor_status*/, gss_const_name_t /*input_name*/, gss_OID_set * /*mech_types*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_canonicalize_name ( OM_uint32 * /*minor_status*/, gss_const_name_t /*input_name*/, const gss_OID /*mech_type*/, gss_name_t * /*output_name*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_duplicate_name ( OM_uint32 * /*minor_status*/, gss_const_name_t /*src_name*/, gss_name_t * /*dest_name*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_duplicate_oid ( OM_uint32 * /* minor_status */, gss_OID /* src_oid */, gss_OID * /* dest_oid */ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_release_oid (OM_uint32 * /*minor_status*/, gss_OID * /* oid */ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_oid_to_str( OM_uint32 * /*minor_status*/, gss_OID /* oid */, gss_buffer_t /* str */ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_inquire_sec_context_by_oid( OM_uint32 * minor_status, gss_const_ctx_id_t context_handle, const gss_OID desired_object, gss_buffer_set_t *data_set ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_set_sec_context_option (OM_uint32 *minor_status, gss_ctx_id_t *context_handle, const gss_OID desired_object, const gss_buffer_t value); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_set_cred_option (OM_uint32 *minor_status, gss_cred_id_t *cred_handle, const gss_OID object, const gss_buffer_t value); GSSAPI_LIB_FUNCTION int GSSAPI_LIB_CALL gss_oid_equal(gss_const_OID a, gss_const_OID b); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_create_empty_buffer_set (OM_uint32 * minor_status, gss_buffer_set_t *buffer_set); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_add_buffer_set_member (OM_uint32 * minor_status, const gss_buffer_t member_buffer, gss_buffer_set_t *buffer_set); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_release_buffer_set (OM_uint32 * minor_status, gss_buffer_set_t *buffer_set); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_inquire_cred_by_oid(OM_uint32 *minor_status, gss_const_cred_id_t cred_handle, const gss_OID desired_object, gss_buffer_set_t *data_set); /* * RFC 4401 */ #define GSS_C_PRF_KEY_FULL 0 #define GSS_C_PRF_KEY_PARTIAL 1 GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_pseudo_random (OM_uint32 *minor_status, gss_ctx_id_t context, int prf_key, const gss_buffer_t prf_in, ssize_t desired_output_len, gss_buffer_t prf_out ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_store_cred(OM_uint32 * /* minor_status */, gss_cred_id_t /* input_cred_handle */, gss_cred_usage_t /* cred_usage */, const gss_OID /* desired_mech */, OM_uint32 /* overwrite_cred */, OM_uint32 /* default_cred */, gss_OID_set * /* elements_stored */, gss_cred_usage_t * /* cred_usage_stored */); /* * Query functions */ typedef struct { size_t header; /**< size of header */ size_t trailer; /**< size of trailer */ size_t max_msg_size; /**< maximum message size */ size_t buffers; /**< extra GSS_IOV_BUFFER_TYPE_EMPTY buffer to pass */ size_t blocksize; /**< Specificed optimal size of messages, also is the maximum padding size (GSS_IOV_BUFFER_TYPE_PADDING) */ } gss_context_stream_sizes; extern gss_OID_desc GSSAPI_LIB_VARIABLE __gss_c_attr_stream_sizes_oid_desc; #define GSS_C_ATTR_STREAM_SIZES (&__gss_c_attr_stream_sizes_oid_desc) GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_context_query_attributes(OM_uint32 * /* minor_status */, gss_const_ctx_id_t /* context_handle */, const gss_OID /* attribute */, void * /*data*/, size_t /* len */); /* * The following routines are obsolete variants of gss_get_mic, * gss_verify_mic, gss_wrap and gss_unwrap. They should be * provided by GSSAPI V2 implementations for backwards * compatibility with V1 applications. Distinct entrypoints * (as opposed to #defines) should be provided, both to allow * GSSAPI V1 applications to link against GSSAPI V2 implementations, * and to retain the slight parameter type differences between the * obsolete versions of these routines and their current forms. */ GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_sign (OM_uint32 * /*minor_status*/, gss_ctx_id_t /*context_handle*/, int /*qop_req*/, gss_buffer_t /*message_buffer*/, gss_buffer_t /*message_token*/ ) GSSAPI_DEPRECATED_FUNCTION("Use gss_get_mic"); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_verify (OM_uint32 * /*minor_status*/, gss_ctx_id_t /*context_handle*/, gss_buffer_t /*message_buffer*/, gss_buffer_t /*token_buffer*/, int * /*qop_state*/ ) GSSAPI_DEPRECATED_FUNCTION("Use gss_verify_mic"); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_seal (OM_uint32 * /*minor_status*/, gss_ctx_id_t /*context_handle*/, int /*conf_req_flag*/, int /*qop_req*/, gss_buffer_t /*input_message_buffer*/, int * /*conf_state*/, gss_buffer_t /*output_message_buffer*/ ) GSSAPI_DEPRECATED_FUNCTION("Use gss_wrap"); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_unseal (OM_uint32 * /*minor_status*/, gss_ctx_id_t /*context_handle*/, gss_buffer_t /*input_message_buffer*/, gss_buffer_t /*output_message_buffer*/, int * /*conf_state*/, int * /*qop_state*/ ) GSSAPI_DEPRECATED_FUNCTION("Use gss_unwrap"); /** * */ GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_encapsulate_token(gss_const_buffer_t /* input_token */, gss_const_OID /* oid */, gss_buffer_t /* output_token */); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_decapsulate_token(gss_const_buffer_t /* input_token */, gss_const_OID /* oid */, gss_buffer_t /* output_token */); /* * AEAD support */ /* * GSS_IOV */ GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_wrap_iov(OM_uint32 *, gss_ctx_id_t, int, gss_qop_t, int *, gss_iov_buffer_desc *, int); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_unwrap_iov(OM_uint32 *, gss_ctx_id_t, int *, gss_qop_t *, gss_iov_buffer_desc *, int); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_wrap_iov_length(OM_uint32 *, gss_ctx_id_t, int, gss_qop_t, int *, gss_iov_buffer_desc *, int); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_release_iov_buffer(OM_uint32 *, gss_iov_buffer_desc *, int); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_wrap_aead(OM_uint32 *, gss_ctx_id_t, int, gss_qop_t, gss_buffer_t, gss_buffer_t, int *, gss_buffer_t); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_unwrap_aead(OM_uint32 *, gss_ctx_id_t, gss_buffer_t, gss_buffer_t, gss_buffer_t, int *, gss_qop_t *); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_export_cred(OM_uint32 * /* minor_status */, gss_cred_id_t /* cred_handle */, gss_buffer_t /* cred_token */); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_import_cred(OM_uint32 * /* minor_status */, gss_buffer_t /* cred_token */, gss_cred_id_t * /* cred_handle */); /* * mech option */ GSSAPI_LIB_FUNCTION int GSSAPI_LIB_CALL gss_mo_set(gss_const_OID mech, gss_const_OID option, int enable, gss_buffer_t value); GSSAPI_LIB_FUNCTION int GSSAPI_LIB_CALL gss_mo_get(gss_const_OID mech, gss_const_OID option, gss_buffer_t value); GSSAPI_LIB_FUNCTION void GSSAPI_LIB_CALL gss_mo_list(gss_const_OID mech, gss_OID_set *options); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_mo_name(gss_const_OID mech, gss_const_OID options, gss_buffer_t name); /* * SASL glue functions and mech inquire */ GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_inquire_saslname_for_mech(OM_uint32 *minor_status, const gss_OID desired_mech, gss_buffer_t sasl_mech_name, gss_buffer_t mech_name, gss_buffer_t mech_description); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_inquire_mech_for_saslname(OM_uint32 *minor_status, const gss_buffer_t sasl_mech_name, gss_OID *mech_type); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_indicate_mechs_by_attrs(OM_uint32 * minor_status, gss_const_OID_set desired_mech_attrs, gss_const_OID_set except_mech_attrs, gss_const_OID_set critical_mech_attrs, gss_OID_set *mechs); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_inquire_attrs_for_mech(OM_uint32 * minor_status, gss_const_OID mech, gss_OID_set *mech_attr, gss_OID_set *known_mech_attrs); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_display_mech_attr(OM_uint32 * minor_status, gss_const_OID mech_attr, gss_buffer_t name, gss_buffer_t short_desc, gss_buffer_t long_desc); /* * Solaris compat */ GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_acquire_cred_with_password (OM_uint32 * /*minor_status*/, gss_const_name_t /*desired_name*/, const gss_buffer_t /*password*/, OM_uint32 /*time_req*/, const gss_OID_set /*desired_mechs*/, gss_cred_usage_t /*cred_usage*/, gss_cred_id_t * /*output_cred_handle*/, gss_OID_set * /*actual_mechs*/, OM_uint32 * /*time_rec*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_add_cred_with_password ( OM_uint32 * /*minor_status*/, gss_const_cred_id_t /*input_cred_handle*/, gss_const_name_t /*desired_name*/, const gss_OID /*desired_mech*/, const gss_buffer_t /*password*/, gss_cred_usage_t /*cred_usage*/, OM_uint32 /*initiator_time_req*/, OM_uint32 /*acceptor_time_req*/, gss_cred_id_t * /*output_cred_handle*/, gss_OID_set * /*actual_mechs*/, OM_uint32 * /*initiator_time_rec*/, OM_uint32 * /*acceptor_time_rec*/ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_localname( OM_uint32 *minor, gss_const_name_t name, const gss_OID mech_type, gss_buffer_t localname); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_pname_to_uid( OM_uint32 *minor, gss_const_name_t name, const gss_OID mech_type, uid_t *uidOut); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_authorize_localname( OM_uint32 *minor, gss_const_name_t name, gss_const_name_t user); GSSAPI_LIB_FUNCTION int GSSAPI_LIB_CALL gss_userok(gss_const_name_t name, const char *user); extern GSSAPI_LIB_VARIABLE gss_buffer_desc __gss_c_attr_local_login_user; #define GSS_C_ATTR_LOCAL_LOGIN_USER (&__gss_c_attr_local_login_user) /* * Naming extensions */ GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_display_name_ext ( OM_uint32 *, /* minor_status */ gss_name_t, /* name */ gss_OID, /* display_as_name_type */ gss_buffer_t /* display_name */ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_inquire_name ( OM_uint32 *, /* minor_status */ gss_name_t, /* name */ int *, /* name_is_MN */ gss_OID *, /* MN_mech */ gss_buffer_set_t * /* attrs */ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_get_name_attribute ( OM_uint32 *, /* minor_status */ gss_name_t, /* name */ gss_buffer_t, /* attr */ int *, /* authenticated */ int *, /* complete */ gss_buffer_t, /* value */ gss_buffer_t, /* display_value */ int * /* more */ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_set_name_attribute ( OM_uint32 *, /* minor_status */ gss_name_t, /* name */ int, /* complete */ gss_buffer_t, /* attr */ gss_buffer_t /* value */ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_delete_name_attribute ( OM_uint32 *, /* minor_status */ gss_name_t, /* name */ gss_buffer_t /* attr */ ); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_export_name_composite ( OM_uint32 *, /* minor_status */ gss_name_t, /* name */ gss_buffer_t /* exp_composite_name */ ); /* * */ GSSAPI_LIB_FUNCTION const char * GSSAPI_LIB_CALL gss_oid_to_name(gss_const_OID oid); GSSAPI_LIB_FUNCTION gss_OID GSSAPI_LIB_CALL gss_name_to_oid(const char *name); GSSAPI_CPP_END #if defined(__APPLE__) && (defined(__ppc__) || defined(__ppc64__) || defined(__i386__) || defined(__x86_64__)) #pragma pack(pop) #endif #undef GSSAPI_DEPRECATED_FUNCTION #endif /* GSSAPI_GSSAPI_H_ */ pykrb5-0.8.0/build_helpers/heimdal/include/gssapi/gssapi_krb5.h000066400000000000000000000150561505521762700244730ustar00rootroot00000000000000/* * Copyright (c) 1997 - 2006 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef GSSAPI_KRB5_H_ #define GSSAPI_KRB5_H_ #include #include GSSAPI_CPP_START #if !defined(__GNUC__) && !defined(__attribute__) #define __attribute__(x) #endif #ifndef GSSKRB5_FUNCTION_DEPRECATED #define GSSKRB5_FUNCTION_DEPRECATED __attribute__((deprecated)) #endif /* * This is for kerberos5 names. */ extern gss_OID_desc GSSAPI_LIB_VARIABLE __gss_krb5_nt_principal_name_oid_desc; #define GSS_KRB5_NT_PRINCIPAL_NAME (&__gss_krb5_nt_principal_name_oid_desc) #define GSS_KRB5_NT_USER_NAME (&__gss_c_nt_user_name_oid_desc) #define GSS_KRB5_NT_MACHINE_UID_NAME (&__gss_c_nt_machine_uid_name_oid_desc) #define GSS_KRB5_NT_STRING_UID_NAME (&__gss_c_nt_string_uid_name_oid_desc) /* for compatibility with MIT api */ #define gss_mech_krb5 GSS_KRB5_MECHANISM #define gss_krb5_nt_general_name GSS_KRB5_NT_PRINCIPAL_NAME /* * kerberos mechanism specific functions */ struct krb5_keytab_data; struct krb5_ccache_data; struct Principal; GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_krb5_ccache_name(OM_uint32 * /*minor_status*/, const char * /*name */, const char ** /*out_name */); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gsskrb5_register_acceptor_identity (const char * /*identity*/); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL krb5_gss_register_acceptor_identity (const char * /*identity*/); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_krb5_copy_ccache (OM_uint32 * /*minor*/, gss_cred_id_t /*cred*/, struct krb5_ccache_data * /*out*/); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_krb5_import_cred(OM_uint32 * /*minor*/, struct krb5_ccache_data * /*in*/, struct Principal * /*keytab_principal*/, struct krb5_keytab_data * /*keytab*/, gss_cred_id_t * /*out*/); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_krb5_get_tkt_flags (OM_uint32 * /*minor*/, gss_ctx_id_t /*context_handle*/, OM_uint32 * /*tkt_flags*/); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gsskrb5_extract_authz_data_from_sec_context (OM_uint32 * /*minor_status*/, gss_ctx_id_t /*context_handle*/, int /*ad_type*/, gss_buffer_t /*ad_data*/); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gsskrb5_set_dns_canonicalize(int); struct gsskrb5_send_to_kdc { void *func; void *ptr; }; GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gsskrb5_set_send_to_kdc(struct gsskrb5_send_to_kdc *) GSSKRB5_FUNCTION_DEPRECATED; GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gsskrb5_set_default_realm(const char *); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gsskrb5_extract_authtime_from_sec_context(OM_uint32 *, gss_ctx_id_t, time_t *); struct EncryptionKey; GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gsskrb5_extract_service_keyblock(OM_uint32 *minor_status, gss_ctx_id_t context_handle, struct EncryptionKey **out); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gsskrb5_get_initiator_subkey(OM_uint32 *minor_status, gss_ctx_id_t context_handle, struct EncryptionKey **out); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gsskrb5_get_subkey(OM_uint32 *minor_status, gss_ctx_id_t context_handle, struct EncryptionKey **out); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gsskrb5_set_time_offset(int); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gsskrb5_get_time_offset(int *); struct gsskrb5_krb5_plugin { int type; char *name; void *symbol; }; GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gsskrb5_plugin_register(struct gsskrb5_krb5_plugin *); /* * Lucid - NFSv4 interface to GSS-API KRB5 to expose key material to * do GSS content token handling in-kernel. */ typedef struct gss_krb5_lucid_key { OM_uint32 type; OM_uint32 length; void * data; } gss_krb5_lucid_key_t; typedef struct gss_krb5_rfc1964_keydata { OM_uint32 sign_alg; OM_uint32 seal_alg; gss_krb5_lucid_key_t ctx_key; } gss_krb5_rfc1964_keydata_t; typedef struct gss_krb5_cfx_keydata { OM_uint32 have_acceptor_subkey; gss_krb5_lucid_key_t ctx_key; gss_krb5_lucid_key_t acceptor_subkey; } gss_krb5_cfx_keydata_t; typedef struct gss_krb5_lucid_context_v1 { OM_uint32 version; OM_uint32 initiate; OM_uint32 endtime; OM_uint64 send_seq; OM_uint64 recv_seq; OM_uint32 protocol; gss_krb5_rfc1964_keydata_t rfc1964_kd; gss_krb5_cfx_keydata_t cfx_kd; } gss_krb5_lucid_context_v1_t; typedef struct gss_krb5_lucid_context_version { OM_uint32 version; /* Structure version number */ } gss_krb5_lucid_context_version_t; /* * Function declarations */ GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_krb5_export_lucid_sec_context(OM_uint32 *minor_status, gss_ctx_id_t *context_handle, OM_uint32 version, void **kctx); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_krb5_free_lucid_sec_context(OM_uint32 *minor_status, void *kctx); GSSAPI_LIB_FUNCTION OM_uint32 GSSAPI_LIB_CALL gss_krb5_set_allowable_enctypes(OM_uint32 *minor_status, gss_cred_id_t cred, OM_uint32 num_enctypes, int32_t *enctypes); GSSAPI_CPP_END #endif /* GSSAPI_SPNEGO_H_ */ pykrb5-0.8.0/build_helpers/heimdal/include/gssapi/gssapi_ntlm.h000066400000000000000000000033321505521762700245740ustar00rootroot00000000000000/* * Copyright (c) 2006 - 2009 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef GSSAPI_NTLM_H_ #define GSSAPI_NTLM_H_ #include #endif /* GSSAPI_NTLM_H_ */ pykrb5-0.8.0/build_helpers/heimdal/include/gssapi/gssapi_oid.h000066400000000000000000000261571505521762700244070ustar00rootroot00000000000000/* Generated file */ #ifndef GSSAPI_GSSAPI_OID #define GSSAPI_GSSAPI_OID 1 /* contact Love Hörnquist Ã…strand for new oid arcs */ /* * 1.2.752.43.13 Heimdal GSS-API Extentions */ extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_copy_ccache_x_oid_desc; #define GSS_KRB5_COPY_CCACHE_X (&__gss_krb5_copy_ccache_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_get_tkt_flags_x_oid_desc; #define GSS_KRB5_GET_TKT_FLAGS_X (&__gss_krb5_get_tkt_flags_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_extract_authz_data_from_sec_context_x_oid_desc; #define GSS_KRB5_EXTRACT_AUTHZ_DATA_FROM_SEC_CONTEXT_X (&__gss_krb5_extract_authz_data_from_sec_context_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_compat_des3_mic_x_oid_desc; #define GSS_KRB5_COMPAT_DES3_MIC_X (&__gss_krb5_compat_des3_mic_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_register_acceptor_identity_x_oid_desc; #define GSS_KRB5_REGISTER_ACCEPTOR_IDENTITY_X (&__gss_krb5_register_acceptor_identity_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_export_lucid_context_x_oid_desc; #define GSS_KRB5_EXPORT_LUCID_CONTEXT_X (&__gss_krb5_export_lucid_context_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_export_lucid_context_v1_x_oid_desc; #define GSS_KRB5_EXPORT_LUCID_CONTEXT_V1_X (&__gss_krb5_export_lucid_context_v1_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_set_dns_canonicalize_x_oid_desc; #define GSS_KRB5_SET_DNS_CANONICALIZE_X (&__gss_krb5_set_dns_canonicalize_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_get_subkey_x_oid_desc; #define GSS_KRB5_GET_SUBKEY_X (&__gss_krb5_get_subkey_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_get_initiator_subkey_x_oid_desc; #define GSS_KRB5_GET_INITIATOR_SUBKEY_X (&__gss_krb5_get_initiator_subkey_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_get_acceptor_subkey_x_oid_desc; #define GSS_KRB5_GET_ACCEPTOR_SUBKEY_X (&__gss_krb5_get_acceptor_subkey_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_send_to_kdc_x_oid_desc; #define GSS_KRB5_SEND_TO_KDC_X (&__gss_krb5_send_to_kdc_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_get_authtime_x_oid_desc; #define GSS_KRB5_GET_AUTHTIME_X (&__gss_krb5_get_authtime_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_get_service_keyblock_x_oid_desc; #define GSS_KRB5_GET_SERVICE_KEYBLOCK_X (&__gss_krb5_get_service_keyblock_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_set_allowable_enctypes_x_oid_desc; #define GSS_KRB5_SET_ALLOWABLE_ENCTYPES_X (&__gss_krb5_set_allowable_enctypes_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_set_default_realm_x_oid_desc; #define GSS_KRB5_SET_DEFAULT_REALM_X (&__gss_krb5_set_default_realm_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_ccache_name_x_oid_desc; #define GSS_KRB5_CCACHE_NAME_X (&__gss_krb5_ccache_name_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_set_time_offset_x_oid_desc; #define GSS_KRB5_SET_TIME_OFFSET_X (&__gss_krb5_set_time_offset_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_get_time_offset_x_oid_desc; #define GSS_KRB5_GET_TIME_OFFSET_X (&__gss_krb5_get_time_offset_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_plugin_register_x_oid_desc; #define GSS_KRB5_PLUGIN_REGISTER_X (&__gss_krb5_plugin_register_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_ntlm_get_session_key_x_oid_desc; #define GSS_NTLM_GET_SESSION_KEY_X (&__gss_ntlm_get_session_key_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_nt_ntlm_oid_desc; #define GSS_C_NT_NTLM (&__gss_c_nt_ntlm_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_nt_dn_oid_desc; #define GSS_C_NT_DN (&__gss_c_nt_dn_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_nt_principal_name_referral_oid_desc; #define GSS_KRB5_NT_PRINCIPAL_NAME_REFERRAL (&__gss_krb5_nt_principal_name_referral_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ntlm_avguest_oid_desc; #define GSS_C_NTLM_AVGUEST (&__gss_c_ntlm_avguest_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ntlm_v1_oid_desc; #define GSS_C_NTLM_V1 (&__gss_c_ntlm_v1_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ntlm_v2_oid_desc; #define GSS_C_NTLM_V2 (&__gss_c_ntlm_v2_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ntlm_session_key_oid_desc; #define GSS_C_NTLM_SESSION_KEY (&__gss_c_ntlm_session_key_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ntlm_force_v1_oid_desc; #define GSS_C_NTLM_FORCE_V1 (&__gss_c_ntlm_force_v1_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_cred_no_ci_flags_x_oid_desc; #define GSS_KRB5_CRED_NO_CI_FLAGS_X (&__gss_krb5_cred_no_ci_flags_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_import_cred_x_oid_desc; #define GSS_KRB5_IMPORT_CRED_X (&__gss_krb5_import_cred_x_oid_desc) /* glue for gss_inquire_saslname_for_mech */ extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_sasl_mech_name_oid_desc; #define GSS_C_MA_SASL_MECH_NAME (&__gss_c_ma_sasl_mech_name_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_mech_name_oid_desc; #define GSS_C_MA_MECH_NAME (&__gss_c_ma_mech_name_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_mech_description_oid_desc; #define GSS_C_MA_MECH_DESCRIPTION (&__gss_c_ma_mech_description_oid_desc) /* credential types */ extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_cred_password_oid_desc; #define GSS_C_CRED_PASSWORD (&__gss_c_cred_password_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_cred_certificate_oid_desc; #define GSS_C_CRED_CERTIFICATE (&__gss_c_cred_certificate_oid_desc) /* Heimdal mechanisms - 1.2.752.43.14 */ extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_sasl_digest_md5_mechanism_oid_desc; #define GSS_SASL_DIGEST_MD5_MECHANISM (&__gss_sasl_digest_md5_mechanism_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_netlogon_mechanism_oid_desc; #define GSS_NETLOGON_MECHANISM (&__gss_netlogon_mechanism_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_netlogon_set_session_key_x_oid_desc; #define GSS_NETLOGON_SET_SESSION_KEY_X (&__gss_netlogon_set_session_key_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_netlogon_set_sign_algorithm_x_oid_desc; #define GSS_NETLOGON_SET_SIGN_ALGORITHM_X (&__gss_netlogon_set_sign_algorithm_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_netlogon_nt_netbios_dns_name_oid_desc; #define GSS_NETLOGON_NT_NETBIOS_DNS_NAME (&__gss_netlogon_nt_netbios_dns_name_oid_desc) /* GSS_KRB5_EXTRACT_AUTHZ_DATA_FROM_SEC_CONTEXT_X.128 */ extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_inq_win2k_pac_x_oid_desc; #define GSS_C_INQ_WIN2K_PAC_X (&__gss_c_inq_win2k_pac_x_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_inq_sspi_session_key_oid_desc; #define GSS_C_INQ_SSPI_SESSION_KEY (&__gss_c_inq_sspi_session_key_oid_desc) /* * "Standard" mechs */ extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_krb5_mechanism_oid_desc; #define GSS_KRB5_MECHANISM (&__gss_krb5_mechanism_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_ntlm_mechanism_oid_desc; #define GSS_NTLM_MECHANISM (&__gss_ntlm_mechanism_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_spnego_mechanism_oid_desc; #define GSS_SPNEGO_MECHANISM (&__gss_spnego_mechanism_oid_desc) /* From Luke Howard */ extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_peer_has_updated_spnego_oid_desc; #define GSS_C_PEER_HAS_UPDATED_SPNEGO (&__gss_c_peer_has_updated_spnego_oid_desc) /* * OID mappings with name and short description and and slightly longer description */ /* * RFC5587 */ extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_mech_concrete_oid_desc; #define GSS_C_MA_MECH_CONCRETE (&__gss_c_ma_mech_concrete_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_mech_pseudo_oid_desc; #define GSS_C_MA_MECH_PSEUDO (&__gss_c_ma_mech_pseudo_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_mech_composite_oid_desc; #define GSS_C_MA_MECH_COMPOSITE (&__gss_c_ma_mech_composite_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_mech_nego_oid_desc; #define GSS_C_MA_MECH_NEGO (&__gss_c_ma_mech_nego_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_mech_glue_oid_desc; #define GSS_C_MA_MECH_GLUE (&__gss_c_ma_mech_glue_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_not_mech_oid_desc; #define GSS_C_MA_NOT_MECH (&__gss_c_ma_not_mech_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_deprecated_oid_desc; #define GSS_C_MA_DEPRECATED (&__gss_c_ma_deprecated_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_not_dflt_mech_oid_desc; #define GSS_C_MA_NOT_DFLT_MECH (&__gss_c_ma_not_dflt_mech_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_itok_framed_oid_desc; #define GSS_C_MA_ITOK_FRAMED (&__gss_c_ma_itok_framed_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_auth_init_oid_desc; #define GSS_C_MA_AUTH_INIT (&__gss_c_ma_auth_init_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_auth_targ_oid_desc; #define GSS_C_MA_AUTH_TARG (&__gss_c_ma_auth_targ_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_auth_init_init_oid_desc; #define GSS_C_MA_AUTH_INIT_INIT (&__gss_c_ma_auth_init_init_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_auth_targ_init_oid_desc; #define GSS_C_MA_AUTH_TARG_INIT (&__gss_c_ma_auth_targ_init_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_auth_init_anon_oid_desc; #define GSS_C_MA_AUTH_INIT_ANON (&__gss_c_ma_auth_init_anon_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_auth_targ_anon_oid_desc; #define GSS_C_MA_AUTH_TARG_ANON (&__gss_c_ma_auth_targ_anon_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_deleg_cred_oid_desc; #define GSS_C_MA_DELEG_CRED (&__gss_c_ma_deleg_cred_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_integ_prot_oid_desc; #define GSS_C_MA_INTEG_PROT (&__gss_c_ma_integ_prot_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_conf_prot_oid_desc; #define GSS_C_MA_CONF_PROT (&__gss_c_ma_conf_prot_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_mic_oid_desc; #define GSS_C_MA_MIC (&__gss_c_ma_mic_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_wrap_oid_desc; #define GSS_C_MA_WRAP (&__gss_c_ma_wrap_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_prot_ready_oid_desc; #define GSS_C_MA_PROT_READY (&__gss_c_ma_prot_ready_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_replay_det_oid_desc; #define GSS_C_MA_REPLAY_DET (&__gss_c_ma_replay_det_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_oos_det_oid_desc; #define GSS_C_MA_OOS_DET (&__gss_c_ma_oos_det_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_cbindings_oid_desc; #define GSS_C_MA_CBINDINGS (&__gss_c_ma_cbindings_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_pfs_oid_desc; #define GSS_C_MA_PFS (&__gss_c_ma_pfs_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_compress_oid_desc; #define GSS_C_MA_COMPRESS (&__gss_c_ma_compress_oid_desc) extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_c_ma_ctx_trans_oid_desc; #define GSS_C_MA_CTX_TRANS (&__gss_c_ma_ctx_trans_oid_desc) #endif /* GSSAPI_GSSAPI_OID */ pykrb5-0.8.0/build_helpers/heimdal/include/gssapi/gssapi_spnego.h000066400000000000000000000041761505521762700251240ustar00rootroot00000000000000/* * Copyright (c) 1997 - 2006 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef GSSAPI_SPNEGO_H_ #define GSSAPI_SPNEGO_H_ #include GSSAPI_CPP_START /* * RFC2478, SPNEGO: * The security mechanism of the initial * negotiation token is identified by the Object Identifier * iso.org.dod.internet.security.mechanism.snego (1.3.6.1.5.5.2). */ extern GSSAPI_LIB_VARIABLE gss_OID_desc __gss_spnego_mechanism_oid_desc; #define GSS_SPNEGO_MECHANISM (&__gss_spnego_mechanism_oid_desc) #define gss_mech_spnego GSS_SPNEGO_MECHANISM GSSAPI_CPP_END #endif /* GSSAPI_SPNEGO_H_ */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/000077500000000000000000000000001505521762700223045ustar00rootroot00000000000000pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/aes.h000066400000000000000000000054021505521762700232260ustar00rootroot00000000000000/* * Copyright (c) 2003-2004 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef HEIM_AES_H #define HEIM_AES_H 1 /* symbol renaming */ #define AES_set_encrypt_key hc_AES_set_encrypt_key #define AES_set_decrypt_key hc_AES_decrypt_key #define AES_encrypt hc_AES_encrypt #define AES_decrypt hc_AES_decrypt #define AES_cbc_encrypt hc_AES_cbc_encrypt #define AES_cfb8_encrypt hc_AES_cfb8_encrypt /* * */ #define AES_BLOCK_SIZE 16 #define AES_MAXNR 14 #define AES_ENCRYPT 1 #define AES_DECRYPT 0 typedef struct aes_key { uint32_t key[(AES_MAXNR+1)*4]; int rounds; } AES_KEY; #ifdef __cplusplus extern "C" { #endif int AES_set_encrypt_key(const unsigned char *, const int, AES_KEY *); int AES_set_decrypt_key(const unsigned char *, const int, AES_KEY *); void AES_encrypt(const unsigned char *, unsigned char *, const AES_KEY *); void AES_decrypt(const unsigned char *, unsigned char *, const AES_KEY *); void AES_cbc_encrypt(const unsigned char *, unsigned char *, unsigned long, const AES_KEY *, unsigned char *, int); void AES_cfb8_encrypt(const unsigned char *, unsigned char *, unsigned long, const AES_KEY *, unsigned char *, int); #ifdef __cplusplus } #endif #endif /* HEIM_AES_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/bn.h000066400000000000000000000100671505521762700230600ustar00rootroot00000000000000/* * Copyright (c) 2006-2016 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * $Id$ */ #ifndef _HEIM_BN_H #define _HEIM_BN_H 1 /* symbol renaming */ #define BN_GENCB_call hc_BN_GENCB_call #define BN_GENCB_set hc_BN_GENCB_set #define BN_bin2bn hc_BN_bin2bn #define BN_bn2bin hc_BN_bn2bin #define BN_bn2hex hc_BN_bn2hex #define BN_clear hc_BN_clear #define BN_clear_bit hc_BN_clear_bit #define BN_clear_free hc_BN_clear_free #define BN_cmp hc_BN_cmp #define BN_dup hc_BN_dup #define BN_free hc_BN_free #define BN_is_negative hc_BN_is_negative #define BN_get_word hc_BN_get_word #define BN_hex2bn hc_BN_hex2bn #define BN_is_bit_set hc_BN_is_bit_set #define BN_new hc_BN_new #define BN_num_bits hc_BN_num_bits #define BN_num_bytes hc_BN_num_bytes #define BN_rand hc_BN_rand #define BN_set_bit hc_BN_set_bit #define BN_set_negative hc_BN_set_negative #define BN_set_word hc_BN_set_word #define BN_uadd hc_BN_uadd #define BN_CTX_new hc_BN_CTX_new #define BN_CTX_free hc_BN_CTX_free #define BN_CTX_get hc_BN_CTX_get #define BN_CTX_start hc_BN_CTX_start #define BN_CTX_end hc_BN_CTX_end #define BIGNUM hc_BIGNUM #define BN_GENCB hc_BN_GENCB #define BN_CTX hc_BN_CTX #define BN_BLINDING hc_BN_BLINDING #define BN_MONT_CTX hc_BN_MONT_CTX /* * */ typedef struct BIGNUM BIGNUM; typedef struct BN_GENCB BN_GENCB; typedef struct BN_CTX BN_CTX; typedef struct BN_MONT_CTX BN_MONT_CTX; typedef struct BN_BLINDING BN_BLINDING; struct BN_GENCB { unsigned int ver; void *arg; union { int (*cb_2)(int, int, BN_GENCB *); } cb; }; /* * */ BIGNUM *BN_new(void); void BN_free(BIGNUM *); void BN_clear_free(BIGNUM *); void BN_clear(BIGNUM *); BIGNUM *BN_dup(const BIGNUM *); int BN_num_bits(const BIGNUM *); int BN_num_bytes(const BIGNUM *); int BN_cmp(const BIGNUM *, const BIGNUM *); void BN_set_negative(BIGNUM *, int); int BN_is_negative(const BIGNUM *); int BN_is_bit_set(const BIGNUM *, int); int BN_set_bit(BIGNUM *, int); int BN_clear_bit(BIGNUM *, int); int BN_set_word(BIGNUM *, unsigned long); unsigned long BN_get_word(const BIGNUM *); BIGNUM *BN_bin2bn(const void *,int len,BIGNUM *); int BN_bn2bin(const BIGNUM *, void *); int BN_hex2bn(BIGNUM **, const char *); char * BN_bn2hex(const BIGNUM *); int BN_uadd(BIGNUM *, const BIGNUM *, const BIGNUM *); int BN_rand(BIGNUM *, int, int, int); void BN_GENCB_set(BN_GENCB *, int (*)(int, int, BN_GENCB *), void *); int BN_GENCB_call(BN_GENCB *, int, int); BN_CTX *BN_CTX_new(void); void BN_CTX_free(BN_CTX *); BIGNUM *BN_CTX_get(BN_CTX *); void BN_CTX_start(BN_CTX *); void BN_CTX_end(BN_CTX *); #endif pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/des.h000066400000000000000000000122301505521762700232260ustar00rootroot00000000000000/* * Copyright (c) 2005 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef _DESperate_H #define _DESperate_H 1 /* symbol renaming */ #define _DES_ipfp_test _hc_DES_ipfp_test #define DES_cbc_cksum hc_DES_cbc_cksum #define DES_cbc_encrypt hc_DES_cbc_encrypt #define DES_cfb64_encrypt hc_DES_cfb64_encrypt #define DES_check_key_parity hc_DES_check_key_parity #define DES_ecb3_encrypt hc_DES_ecb3_encrypt #define DES_ecb_encrypt hc_DES_ecb_encrypt #define DES_ede3_cbc_encrypt hc_DES_ede3_cbc_encrypt #define DES_encrypt hc_DES_encrypt #define DES_generate_random_block hc_DES_generate_random_block #define DES_init_random_number_generator hc_DES_init_random_number_generator #define DES_is_weak_key hc_DES_is_weak_key #define DES_key_sched hc_DES_key_sched #define DES_new_random_key hc_DES_new_random_key #define DES_pcbc_encrypt hc_DES_pcbc_encrypt #define DES_rand_data hc_DES_rand_data #define DES_random_key hc_DES_random_key #define DES_read_password hc_DES_read_password #define DES_set_key hc_DES_set_key #define DES_set_key_checked hc_DES_set_key_checked #define DES_set_key_unchecked hc_DES_set_key_unchecked #define DES_set_key_sched hc_DES_set_key_sched #define DES_set_odd_parity hc_DES_set_odd_parity #define DES_set_random_generator_seed hc_DES_set_random_generator_seed #define DES_set_sequence_number hc_DES_set_sequence_number #define DES_string_to_key hc_DES_string_to_key /* * */ #define DES_CBLOCK_LEN 8 #define DES_KEY_SZ 8 #define DES_ENCRYPT 1 #define DES_DECRYPT 0 typedef unsigned char DES_cblock[DES_CBLOCK_LEN]; typedef struct DES_key_schedule { uint32_t ks[32]; } DES_key_schedule; /* * */ #ifndef HC_DEPRECATED #if defined(__GNUC__) && ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1 ))) #define HC_DEPRECATED __attribute__((deprecated)) #elif defined(_MSC_VER) && (_MSC_VER>1200) #define HC_DEPRECATED __declspec(deprecated) #else #define HC_DEPRECATED #endif #endif #ifdef __cplusplus extern "C" { #endif void DES_set_odd_parity(DES_cblock *); int DES_check_key_parity(DES_cblock *); int DES_is_weak_key(DES_cblock *); int HC_DEPRECATED DES_set_key(DES_cblock *, DES_key_schedule *); int DES_set_key_checked(DES_cblock *, DES_key_schedule *); int DES_set_key_unchecked(DES_cblock *, DES_key_schedule *); int DES_key_sched(DES_cblock *, DES_key_schedule *); void DES_string_to_key(const char *, DES_cblock *); int DES_read_password(DES_cblock *, char *, int); void HC_DEPRECATED DES_rand_data(void *, int); void HC_DEPRECATED DES_set_random_generator_seed(DES_cblock *); void HC_DEPRECATED DES_generate_random_block(DES_cblock *); void HC_DEPRECATED DES_set_sequence_number(void *); void HC_DEPRECATED DES_init_random_number_generator(DES_cblock *); void HC_DEPRECATED DES_random_key(DES_cblock *); int HC_DEPRECATED DES_new_random_key(DES_cblock *); void DES_encrypt(uint32_t [2], DES_key_schedule *, int); void DES_ecb_encrypt(DES_cblock *, DES_cblock *, DES_key_schedule *, int); void DES_ecb3_encrypt(DES_cblock *,DES_cblock *, DES_key_schedule *, DES_key_schedule *, DES_key_schedule *, int); void DES_pcbc_encrypt(const void *, void *, long, DES_key_schedule *, DES_cblock *, int); void DES_cbc_encrypt(const void *, void *, long, DES_key_schedule *, DES_cblock *, int); void DES_ede3_cbc_encrypt(const void *, void *, long, DES_key_schedule *, DES_key_schedule *, DES_key_schedule *, DES_cblock *, int); void DES_cfb64_encrypt(const void *, void *, long, DES_key_schedule *, DES_cblock *, int *, int); uint32_t DES_cbc_cksum(const void *, DES_cblock *, long, DES_key_schedule *, DES_cblock *); void _DES_ipfp_test(void); #ifdef __cplusplus } #endif #endif /* _DESperate_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/dh.h000066400000000000000000000103321505521762700230470ustar00rootroot00000000000000/* * Copyright (c) 2006 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * $Id$ */ #ifndef _HEIM_DH_H #define _HEIM_DH_H 1 /* symbol renaming */ #define DH hc_DH #define DH_METHOD hc_DH_METHOD #define DH_null_method hc_DH_null_method #define DH_tfm_method hc_DH_tfm_method #define DH_ltm_method hc_DH_ltm_method #define DH_new hc_DH_new #define DH_new_method hc_DH_new_method #define DH_free hc_DH_free #define DH_up_ref hc_DH_up_ref #define DH_size hc_DH_size #define DH_set_default_method hc_DH_set_default_method #define DH_get_default_method hc_DH_get_default_method #define DH_set_method hc_DH_set_method #define DH_get_method hc_DH_get_method #define DH_set_ex_data hc_DH_set_ex_data #define DH_get_ex_data hc_DH_get_ex_data #define DH_generate_parameters_ex hc_DH_generate_parameters_ex #define DH_check_pubkey hc_DH_check_pubkey #define DH_generate_key hc_DH_generate_key #define DH_compute_key hc_DH_compute_key #define i2d_DHparams hc_i2d_DHparams /* * */ typedef struct DH DH; typedef struct DH_METHOD DH_METHOD; #include #include struct DH_METHOD { const char *name; int (*generate_key)(DH *); int (*compute_key)(unsigned char *,const BIGNUM *,DH *); int (*bn_mod_exp)(const DH *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *, BN_MONT_CTX *); int (*init)(DH *); int (*finish)(DH *); int flags; void *app_data; int (*generate_params)(DH *, int, int, BN_GENCB *); }; struct DH { int pad; int version; BIGNUM *p; BIGNUM *g; long length; BIGNUM *pub_key; BIGNUM *priv_key; int flags; void *method_mont_p; BIGNUM *q; BIGNUM *j; void *seed; int seedlen; BIGNUM *counter; int references; struct CRYPTO_EX_DATA { void *sk; int dummy; } ex_data; const DH_METHOD *meth; ENGINE *engine; }; /* DH_check_pubkey return codes in `codes' argument. */ #define DH_CHECK_PUBKEY_TOO_SMALL 1 #define DH_CHECK_PUBKEY_TOO_LARGE 2 /* * */ const DH_METHOD *DH_null_method(void); const DH_METHOD *DH_tfm_method(void); const DH_METHOD *DH_ltm_method(void); DH * DH_new(void); DH * DH_new_method(ENGINE *); void DH_free(DH *); int DH_up_ref(DH *); int DH_size(const DH *); void DH_set_default_method(const DH_METHOD *); const DH_METHOD * DH_get_default_method(void); int DH_set_method(DH *, const DH_METHOD *); int DH_set_ex_data(DH *, int, void *); void * DH_get_ex_data(DH *, int); int DH_generate_parameters_ex(DH *, int, int, BN_GENCB *); int DH_check_pubkey(const DH *, const BIGNUM *, int *); int DH_generate_key(DH *); int DH_compute_key(unsigned char *,const BIGNUM *,DH *); int i2d_DHparams(DH *, unsigned char **); #endif /* _HEIM_DH_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/dsa.h000066400000000000000000000075431505521762700232350ustar00rootroot00000000000000/* * Copyright (c) 2006 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * $Id$ */ #ifndef _HEIM_DSA_H #define _HEIM_DSA_H 1 #include /* symbol renaming */ #define DSA hc_DSA #define DSA_METHOD hc_DSA_METHOD #define DSA_null_method hc_DSA_null_method #define DSA_new hc_DSA_new #define DSA_free hc_DSA_free #define DSA_up_ref hc_DSA_up_ref #define DSA_set_default_method hc_DSA_set_default_method #define DSA_get_default_method hc_DSA_get_default_method #define DSA_set_method hc_DSA_set_method #define DSA_get_method hc_DSA_get_method #define DSA_set_app_data hc_DSA_set_app_data #define DSA_get_app_data hc_DSA_get_app_data #define DSA_size hc_DSA_size #define DSA_verify hc_DSA_verify /* * */ typedef struct DSA DSA; typedef struct DSA_METHOD DSA_METHOD; typedef struct DSA_SIG DSA_SIG; struct DSA_SIG { BIGNUM *r; BIGNUM *s; }; struct DSA_METHOD { const char *name; DSA_SIG * (*dsa_do_sign)(const unsigned char *, int, DSA *); int (*dsa_sign_setup)(DSA *, BN_CTX *, BIGNUM **, BIGNUM **); int (*dsa_do_verify)(const unsigned char *, int, DSA_SIG *, DSA *); int (*dsa_mod_exp)(DSA *, BIGNUM *, BIGNUM *, BIGNUM *, BIGNUM *, BIGNUM *, BIGNUM *, BN_CTX *, BN_MONT_CTX *); int (*bn_mod_exp)(DSA *, BIGNUM *, BIGNUM *, const BIGNUM *, const BIGNUM *, BN_CTX *, BN_MONT_CTX *); int (*init)(DSA *); int (*finish)(DSA *); int flags; void *app_data; }; struct DSA { int pad; long version; int write_params; BIGNUM *p; BIGNUM *q; BIGNUM *g; BIGNUM *pub_key; BIGNUM *priv_key; BIGNUM *kinv; BIGNUM *r; int flags; void *method_mont_p; int references; struct dsa_CRYPTO_EX_DATA { void *sk; int dummy; } ex_data; const DSA_METHOD *meth; void *engine; }; /* * */ const DSA_METHOD *DSA_null_method(void); /* * */ DSA * DSA_new(void); void DSA_free(DSA *); int DSA_up_ref(DSA *); void DSA_set_default_method(const DSA_METHOD *); const DSA_METHOD * DSA_get_default_method(void); const DSA_METHOD * DSA_get_method(const DSA *); int DSA_set_method(DSA *, const DSA_METHOD *); void DSA_set_app_data(DSA *, void *arg); void * DSA_get_app_data(DSA *); int DSA_size(const DSA *); int DSA_verify(int, const unsigned char *, int, const unsigned char *, int, DSA *); #endif /* _HEIM_DSA_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/ec.h000066400000000000000000000060771505521762700230560ustar00rootroot00000000000000/* * Copyright (c) 2009-2016 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef HEIM_EC_H #define HEIM_EC_H 1 #define EC_KEY hc_EC_KEY #define EC_GROUP hc_EC_GROUP #define EC_GROUP_ID hc_EC_GROUP_ID #define EC_GROUP_ID_s hc_EC_GROUP_ID_s #define EC_GROUP_get_degree hc_EC_GROUP_get_degree #define EC_KEY_get0_group hc_EC_KEY_get0_group #define EC_GROUP_get_order hc_EC_GROUP_get_order #define o2i_ECPublicKey hc_o2i_ECPublicKey #define EC_KEY_free hc_EC_KEY_free #define EC_GROUP_new_by_curve_name hc_EC_GROUP_new_by_curve_name #define EC_KEY_set_group hc_EC_KEY_set_group #define EC_GROUP_free hc_EC_GROUP_free #define EC_KEY_check_key hc_EC_KEY_check_key #define EC_KEY_get0_private_key hc_EC_KEY_get0_private_key #define EC_KEY_set_private_key hc_EC_KEY_set_private_key #include #include typedef struct EC_KEY EC_KEY; typedef struct EC_GROUP EC_GROUP; typedef struct EC_GROUP_ID_s *EC_GROUP_ID; unsigned long EC_GROUP_get_degree(EC_GROUP *); EC_GROUP * EC_KEY_get0_group(EC_KEY *); int EC_GROUP_get_order(EC_GROUP *, BIGNUM *, BN_CTX *); EC_KEY * o2i_ECPublicKey(EC_KEY **key, unsigned char **, size_t); EC_KEY * EC_KEY_new_by_curve_name(EC_GROUP_ID); int EC_KEY_generate_key(EC_KEY *); void EC_KEY_free(EC_KEY *); EC_GROUP * EC_GROUP_new_by_curve_name(int nid); void EC_KEY_set_group(EC_KEY *, EC_GROUP *); void EC_GROUP_free(EC_GROUP *); int EC_KEY_check_key(const EC_KEY *); const BIGNUM *EC_KEY_get0_private_key(const EC_KEY *); int EC_KEY_set_private_key(EC_KEY *, const BIGNUM *); #endif /* HEIM_EC_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/ecdh.h000066400000000000000000000035651505521762700233710ustar00rootroot00000000000000/* * Copyright (c) 2009 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef HEIM_ECDH_H #define HEIM_ECDH_H 1 #define ECDH_compute_key hc_ECDH_compute_key #include int ECDH_compute_key(void *, size_t, const EC_KEY *, const EC_KEY *, void *(*KDF)(const void *, size_t, void *, size_t *)); #endif /* HEIM_ECDH_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/ecdsa.h000066400000000000000000000040411505521762700235330ustar00rootroot00000000000000/* * Copyright (c) 2009 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef HEIM_ECDSA_H #define HEIM_ECDSA_H 1 #define ECDSA_verify hc_ECDSA_verify #define ECDSA_sign hc_ECDSA_sign #define ECDSA_size hc_ECDSA_size #include int ECDSA_verify(int, const unsigned char *, unsigned int, unsigned char *, unsigned int, EC_KEY *); int ECDSA_sign(int, const unsigned char *, unsigned int, unsigned char *, unsigned int *, EC_KEY *); int ECDSA_size(EC_KEY *); #endif /* HEIM_ECDSA_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/engine.h000066400000000000000000000101111505521762700237140ustar00rootroot00000000000000/* * Copyright (c) 2006-2016 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * $Id$ */ #ifndef _HEIM_ENGINE_H #define _HEIM_ENGINE_H 1 /* symbol renaming */ #define ENGINE_add_conf_module hc_ENGINE_add_conf_module #define ENGINE_by_dso hc_ENGINE_by_dso #define ENGINE_by_id hc_ENGINE_by_id #define ENGINE_finish hc_ENGINE_finish #define ENGINE_get_DH hc_ENGINE_get_DH #define ENGINE_get_RSA hc_ENGINE_get_RSA #define ENGINE_get_RAND hc_ENGINE_get_RAND #define ENGINE_get_id hc_ENGINE_get_id #define ENGINE_get_name hc_ENGINE_get_name #define ENGINE_load_builtin_engines hc_ENGINE_load_builtin_engines #define ENGINE_set_DH hc_ENGINE_set_DH #define ENGINE_set_RSA hc_ENGINE_set_RSA #define ENGINE_set_id hc_ENGINE_set_id #define ENGINE_set_name hc_ENGINE_set_name #define ENGINE_set_destroy_function hc_ENGINE_set_destroy_function #define ENGINE_new hc_ENGINE_new #define ENGINE_free hc_ENGINE_free #define ENGINE_up_ref hc_ENGINE_up_ref #define ENGINE_get_default_DH hc_ENGINE_get_default_DH #define ENGINE_get_default_RSA hc_ENGINE_get_default_RSA #define ENGINE_set_default_DH hc_ENGINE_set_default_DH #define ENGINE_set_default_RSA hc_ENGINE_set_default_RSA #define ENGINE hc_ENGINE /* * */ typedef struct hc_engine ENGINE; #define NID_md2 0 #define NID_md4 1 #define NID_md5 2 #define NID_sha1 4 #define NID_sha256 5 /* * */ #include #include #include #include #define OPENSSL_DYNAMIC_VERSION (unsigned long)0x00020000 typedef int (*openssl_bind_engine)(ENGINE *, const char *, const void *); typedef unsigned long (*openssl_v_check)(unsigned long); ENGINE * ENGINE_new(void); int ENGINE_free(ENGINE *); void ENGINE_add_conf_module(void); void ENGINE_load_builtin_engines(void); ENGINE *ENGINE_by_id(const char *); ENGINE *ENGINE_by_dso(const char *, const char *); int ENGINE_finish(ENGINE *); int ENGINE_up_ref(ENGINE *); int ENGINE_set_id(ENGINE *, const char *); int ENGINE_set_name(ENGINE *, const char *); int ENGINE_set_RSA(ENGINE *, const RSA_METHOD *); int ENGINE_set_DH(ENGINE *, const DH_METHOD *); int ENGINE_set_destroy_function(ENGINE *, void (*)(ENGINE *)); const char * ENGINE_get_id(const ENGINE *); const char * ENGINE_get_name(const ENGINE *); const RSA_METHOD * ENGINE_get_RSA(const ENGINE *); const DH_METHOD * ENGINE_get_DH(const ENGINE *); const RAND_METHOD * ENGINE_get_RAND(const ENGINE *); int ENGINE_set_default_RSA(ENGINE *); ENGINE * ENGINE_get_default_RSA(void); int ENGINE_set_default_DH(ENGINE *); ENGINE * ENGINE_get_default_DH(void); #endif /* _HEIM_ENGINE_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/evp-cc.h000066400000000000000000000073001505521762700236320ustar00rootroot00000000000000/* * Copyright (c) 2009 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef HEIM_EVP_CC_H #define HEIM_EVP_CC_H 1 /* symbol renaming */ #define EVP_cc_md2 hc_EVP_cc_md2 #define EVP_cc_md4 hc_EVP_cc_md4 #define EVP_cc_md5 hc_EVP_cc_md5 #define EVP_cc_sha1 hc_EVP_cc_sha1 #define EVP_cc_sha256 hc_EVP_cc_sha256 #define EVP_cc_sha384 hc_EVP_cc_sha384 #define EVP_cc_sha512 hc_EVP_cc_sha512 #define EVP_cc_des_cbc hc_EVP_cc_des_cbc #define EVP_cc_des_ede3_cbc hc_EVP_cc_des_ede3_cbc #define EVP_cc_aes_128_cbc hc_EVP_cc_aes_128_cbc #define EVP_cc_aes_192_cbc hc_EVP_cc_aes_192_cbc #define EVP_cc_aes_256_cbc hc_EVP_cc_aes_256_cbc #define EVP_cc_aes_128_cfb8 hc_EVP_cc_aes_128_cfb8 #define EVP_cc_aes_192_cfb8 hc_EVP_cc_aes_192_cfb8 #define EVP_cc_aes_256_cfb8 hc_EVP_cc_aes_256_cfb8 #define EVP_cc_rc4 hc_EVP_cc_rc4 #define EVP_cc_rc4_40 hc_EVP_cc_rc4_40 #define EVP_cc_rc2_40_cbc hc_EVP_cc_rc2_40_cbc #define EVP_cc_rc2_64_cbc hc_EVP_cc_rc2_64_cbc #define EVP_cc_rc2_cbc hc_EVP_cc_rc2_cbc #define EVP_cc_camellia_128_cbc hc_EVP_cc_camellia_128_cbc #define EVP_cc_camellia_192_cbc hc_EVP_cc_camellia_192_cbc #define EVP_cc_camellia_256_cbc hc_EVP_cc_camellia_256_cbc /* * */ HC_CPP_BEGIN const EVP_MD * EVP_cc_md2(void); const EVP_MD * EVP_cc_md4(void); const EVP_MD * EVP_cc_md5(void); const EVP_MD * EVP_cc_sha1(void); const EVP_MD * EVP_cc_sha256(void); const EVP_MD * EVP_cc_sha384(void); const EVP_MD * EVP_cc_sha512(void); const EVP_CIPHER * EVP_cc_rc2_cbc(void); const EVP_CIPHER * EVP_cc_rc2_40_cbc(void); const EVP_CIPHER * EVP_cc_rc2_64_cbc(void); const EVP_CIPHER * EVP_cc_rc4(void); const EVP_CIPHER * EVP_cc_rc4_40(void); const EVP_CIPHER * EVP_cc_des_cbc(void); const EVP_CIPHER * EVP_cc_des_ede3_cbc(void); const EVP_CIPHER * EVP_cc_aes_128_cbc(void); const EVP_CIPHER * EVP_cc_aes_192_cbc(void); const EVP_CIPHER * EVP_cc_aes_256_cbc(void); const EVP_CIPHER * EVP_cc_aes_128_cfb8(void); const EVP_CIPHER * EVP_cc_aes_192_cfb8(void); const EVP_CIPHER * EVP_cc_aes_256_cfb8(void); const EVP_CIPHER * EVP_cc_camellia_128_cbc(void); const EVP_CIPHER * EVP_cc_camellia_192_cbc(void); const EVP_CIPHER * EVP_cc_camellia_256_cbc(void); HC_CPP_END #endif /* HEIM_EVP_CC_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/evp-hcrypto.h000066400000000000000000000100511505521762700247320ustar00rootroot00000000000000/* * Copyright (c) 2009 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef HEIM_EVP_HCRYPTO_H #define HEIM_EVP_HCRYPTO_H 1 /* symbol renaming */ #define EVP_hcrypto_md2 hc_EVP_hcrypto_md2 #define EVP_hcrypto_md4 hc_EVP_hcrypto_md4 #define EVP_hcrypto_md5 hc_EVP_hcrypto_md5 #define EVP_hcrypto_sha1 hc_EVP_hcrypto_sha1 #define EVP_hcrypto_sha256 hc_EVP_hcrypto_sha256 #define EVP_hcrypto_sha384 hc_EVP_hcrypto_sha384 #define EVP_hcrypto_sha512 hc_EVP_hcrypto_sha512 #define EVP_hcrypto_des_cbc hc_EVP_hcrypto_des_cbc #define EVP_hcrypto_des_ede3_cbc hc_EVP_hcrypto_des_ede3_cbc #define EVP_hcrypto_aes_128_cbc hc_EVP_hcrypto_aes_128_cbc #define EVP_hcrypto_aes_192_cbc hc_EVP_hcrypto_aes_192_cbc #define EVP_hcrypto_aes_256_cbc hc_EVP_hcrypto_aes_256_cbc #define EVP_hcrypto_aes_128_cfb8 hc_EVP_hcrypto_aes_128_cfb8 #define EVP_hcrypto_aes_192_cfb8 hc_EVP_hcrypto_aes_192_cfb8 #define EVP_hcrypto_aes_256_cfb8 hc_EVP_hcrypto_aes_256_cfb8 #define EVP_hcrypto_rc4 hc_EVP_hcrypto_rc4 #define EVP_hcrypto_rc4_40 hc_EVP_hcrypto_rc4_40 #define EVP_hcrypto_rc2_40_cbc hc_EVP_hcrypto_rc2_40_cbc #define EVP_hcrypto_rc2_64_cbc hc_EVP_hcrypto_rc2_64_cbc #define EVP_hcrypto_rc2_cbc hc_EVP_hcrypto_rc2_cbc #define EVP_hcrypto_camellia_128_cbc hc_EVP_hcrypto_camellia_128_cbc #define EVP_hcrypto_camellia_192_cbc hc_EVP_hcrypto_camellia_192_cbc #define EVP_hcrypto_camellia_256_cbc hc_EVP_hcrypto_camellia_256_cbc /* * */ HC_CPP_BEGIN const EVP_MD * EVP_hcrypto_md2(void); const EVP_MD * EVP_hcrypto_md4(void); const EVP_MD * EVP_hcrypto_md5(void); const EVP_MD * EVP_hcrypto_sha1(void); const EVP_MD * EVP_hcrypto_sha256(void); const EVP_MD * EVP_hcrypto_sha384(void); const EVP_MD * EVP_hcrypto_sha512(void); const EVP_CIPHER * EVP_hcrypto_rc4(void); const EVP_CIPHER * EVP_hcrypto_rc4_40(void); const EVP_CIPHER * EVP_hcrypto_rc2_cbc(void); const EVP_CIPHER * EVP_hcrypto_rc2_40_cbc(void); const EVP_CIPHER * EVP_hcrypto_rc2_64_cbc(void); const EVP_CIPHER * EVP_hcrypto_des_cbc(void); const EVP_CIPHER * EVP_hcrypto_des_ede3_cbc(void); const EVP_CIPHER * EVP_hcrypto_aes_128_cbc(void); const EVP_CIPHER * EVP_hcrypto_aes_192_cbc(void); const EVP_CIPHER * EVP_hcrypto_aes_256_cbc(void); const EVP_CIPHER * EVP_hcrypto_aes_128_cfb8(void); const EVP_CIPHER * EVP_hcrypto_aes_192_cfb8(void); const EVP_CIPHER * EVP_hcrypto_aes_256_cfb8(void); const EVP_CIPHER * EVP_hcrypto_camellia_128_cbc(void); const EVP_CIPHER * EVP_hcrypto_camellia_192_cbc(void); const EVP_CIPHER * EVP_hcrypto_camellia_256_cbc(void); HC_CPP_END #endif /* HEIM_EVP_HCRYPTO_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/evp-openssl.h000066400000000000000000000077371505521762700247460ustar00rootroot00000000000000/* * Copyright (c) 2009-2016 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef HEIM_EVP_OSSL_H #define HEIM_EVP_OSSL_H 1 /* symbol renaming */ #define EVP_ossl_md2 hc_EVP_ossl_md2 #define EVP_ossl_md4 hc_EVP_ossl_md4 #define EVP_ossl_md5 hc_EVP_ossl_md5 #define EVP_ossl_sha1 hc_EVP_ossl_sha1 #define EVP_ossl_sha256 hc_EVP_ossl_sha256 #define EVP_ossl_sha384 hc_EVP_ossl_sha384 #define EVP_ossl_sha512 hc_EVP_ossl_sha512 #define EVP_ossl_des_cbc hc_EVP_ossl_des_cbc #define EVP_ossl_des_ede3_cbc hc_EVP_ossl_des_ede3_cbc #define EVP_ossl_aes_128_cbc hc_EVP_ossl_aes_128_cbc #define EVP_ossl_aes_192_cbc hc_EVP_ossl_aes_192_cbc #define EVP_ossl_aes_256_cbc hc_EVP_ossl_aes_256_cbc #define EVP_ossl_aes_128_cfb8 hc_EVP_ossl_aes_128_cfb8 #define EVP_ossl_aes_192_cfb8 hc_EVP_ossl_aes_192_cfb8 #define EVP_ossl_aes_256_cfb8 hc_EVP_ossl_aes_256_cfb8 #define EVP_ossl_rc4 hc_EVP_ossl_rc4 #define EVP_ossl_rc4_40 hc_EVP_ossl_rc4_40 #define EVP_ossl_rc2_40_cbc hc_EVP_ossl_rc2_40_cbc #define EVP_ossl_rc2_64_cbc hc_EVP_ossl_rc2_64_cbc #define EVP_ossl_rc2_cbc hc_EVP_ossl_rc2_cbc #define EVP_ossl_camellia_128_cbc hc_EVP_ossl_camellia_128_cbc #define EVP_ossl_camellia_192_cbc hc_EVP_ossl_camellia_192_cbc #define EVP_ossl_camellia_256_cbc hc_EVP_ossl_camellia_256_cbc /* * */ HC_CPP_BEGIN const hc_EVP_MD * hc_EVP_ossl_md2(void); const hc_EVP_MD * hc_EVP_ossl_md4(void); const hc_EVP_MD * hc_EVP_ossl_md5(void); const hc_EVP_MD * hc_EVP_ossl_sha1(void); const hc_EVP_MD * hc_EVP_ossl_sha256(void); const hc_EVP_MD * hc_EVP_ossl_sha384(void); const hc_EVP_MD * hc_EVP_ossl_sha512(void); const hc_EVP_CIPHER * hc_EVP_ossl_rc2_cbc(void); const hc_EVP_CIPHER * hc_EVP_ossl_rc2_40_cbc(void); const hc_EVP_CIPHER * hc_EVP_ossl_rc2_64_cbc(void); const hc_EVP_CIPHER * hc_EVP_ossl_rc4(void); const hc_EVP_CIPHER * hc_EVP_ossl_rc4_40(void); const hc_EVP_CIPHER * hc_EVP_ossl_des_cbc(void); const hc_EVP_CIPHER * hc_EVP_ossl_des_ede3_cbc(void); const hc_EVP_CIPHER * hc_EVP_ossl_aes_128_cbc(void); const hc_EVP_CIPHER * hc_EVP_ossl_aes_192_cbc(void); const hc_EVP_CIPHER * hc_EVP_ossl_aes_256_cbc(void); const hc_EVP_CIPHER * hc_EVP_ossl_aes_128_cfb8(void); const hc_EVP_CIPHER * hc_EVP_ossl_aes_192_cfb8(void); const hc_EVP_CIPHER * hc_EVP_ossl_aes_256_cfb8(void); const hc_EVP_CIPHER * hc_EVP_ossl_camellia_128_cbc(void); const hc_EVP_CIPHER * hc_EVP_ossl_camellia_192_cbc(void); const hc_EVP_CIPHER * hc_EVP_ossl_camellia_256_cbc(void); HC_CPP_END #endif /* HEIM_EVP_OSSL_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/evp-pkcs11.h000066400000000000000000000157651505521762700243650ustar00rootroot00000000000000/* * Copyright (c) 2015, Secure Endpoints Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * OF THE POSSIBILITY OF SUCH DAMAGE. */ /* $Id$ */ #ifndef HEIM_EVP_PKCS11_H #define HEIM_EVP_PKCS11_H 1 /* symbol renaming */ #define EVP_pkcs11_md2() hc_EVP_pkcs11_md2() #define EVP_pkcs11_md4() hc_EVP_pkcs11_md4() #define EVP_pkcs11_md5() hc_EVP_pkcs11_md5() #define EVP_pkcs11_sha1() hc_EVP_pkcs11_sha1() #define EVP_pkcs11_sha256() hc_EVP_pkcs11_sha256() #define EVP_pkcs11_sha384() hc_EVP_pkcs11_sha384() #define EVP_pkcs11_sha512() hc_EVP_pkcs11_sha512() #define EVP_pkcs11_des_cbc() hc_EVP_pkcs11_des_cbc() #define EVP_pkcs11_des_ede3_cbc() hc_EVP_pkcs11_des_ede3_cbc() #define EVP_pkcs11_aes_128_cbc() hc_EVP_pkcs11_aes_128_cbc() #define EVP_pkcs11_aes_192_cbc() hc_EVP_pkcs11_aes_192_cbc() #define EVP_pkcs11_aes_256_cbc() hc_EVP_pkcs11_aes_256_cbc() #define EVP_pkcs11_aes_128_cfb8() hc_EVP_pkcs11_aes_128_cfb8() #define EVP_pkcs11_aes_192_cfb8() hc_EVP_pkcs11_aes_192_cfb8() #define EVP_pkcs11_aes_256_cfb8() hc_EVP_pkcs11_aes_256_cfb8() #define EVP_pkcs11_rc4() hc_EVP_pkcs11_rc4() #define EVP_pkcs11_rc4_40() hc_EVP_pkcs11_rc4_40() #define EVP_pkcs11_rc2_40_cbc() hc_EVP_pkcs11_rc2_40_cbc() #define EVP_pkcs11_rc2_64_cbc() hc_EVP_pkcs11_rc2_64_cbc() #define EVP_pkcs11_rc2_cbc() hc_EVP_pkcs11_rc2_cbc() #define EVP_pkcs11_camellia_128_cbc() hc_EVP_pkcs11_camellia_128_cbc() #define EVP_pkcs11_camellia_192_cbc() hc_EVP_pkcs11_camellia_192_cbc() #define EVP_pkcs11_camellia_256_cbc() hc_EVP_pkcs11_camellia_256_cbc() #define EVP_pkcs11_hcrypto_md2() hc_EVP_pkcs11_hcrypto_md2() #define EVP_pkcs11_hcrypto_md4() hc_EVP_pkcs11_hcrypto_md4() #define EVP_pkcs11_hcrypto_md5() hc_EVP_pkcs11_hcrypto_md5() #define EVP_pkcs11_hcrypto_sha1() hc_EVP_pkcs11_hcrypto_sha1() #define EVP_pkcs11_hcrypto_sha256() hc_EVP_pkcs11_hcrypto_sha256() #define EVP_pkcs11_hcrypto_sha384() hc_EVP_pkcs11_hcrypto_sha384() #define EVP_pkcs11_hcrypto_sha512() hc_EVP_pkcs11_hcrypto_sha512() #define EVP_pkcs11_hcrypto_des_cbc() hc_EVP_pkcs11_hcrypto_des_cbc() #define EVP_pkcs11_hcrypto_des_ede3_cbc() hc_EVP_pkcs11_hcrypto_des_ede3_cbc() #define EVP_pkcs11_hcrypto_aes_128_cbc() hc_EVP_pkcs11_hcrypto_aes_128_cbc() #define EVP_pkcs11_hcrypto_aes_192_cbc() hc_EVP_pkcs11_hcrypto_aes_192_cbc() #define EVP_pkcs11_hcrypto_aes_256_cbc() hc_EVP_pkcs11_hcrypto_aes_256_cbc() #define EVP_pkcs11_hcrypto_aes_128_cfb8() hc_EVP_pkcs11_hcrypto_aes_128_cfb8() #define EVP_pkcs11_hcrypto_aes_192_cfb8() hc_EVP_pkcs11_hcrypto_aes_192_cfb8() #define EVP_pkcs11_hcrypto_aes_256_cfb8() hc_EVP_pkcs11_hcrypto_aes_256_cfb8() #define EVP_pkcs11_hcrypto_rc4() hc_EVP_pkcs11_hcrypto_rc4() #define EVP_pkcs11_hcrypto_rc4_40() hc_EVP_pkcs11_hcrypto_rc4_40() #define EVP_pkcs11_hcrypto_rc2_40_cbc() hc_EVP_pkcs11_hcrypto_rc2_40_cbc() #define EVP_pkcs11_hcrypto_rc2_64_cbc() hc_EVP_pkcs11_hcrypto_rc2_64_cbc() #define EVP_pkcs11_hcrypto_rc2_cbc() hc_EVP_pkcs11_hcrypto_rc2_cbc() #define EVP_pkcs11_hcrypto_camellia_128_cbc() hc_EVP_pkcs11_hcrypto_camellia_128_cbc() #define EVP_pkcs11_hcrypto_camellia_192_cbc() hc_EVP_pkcs11_hcrypto_camellia_192_cbc() #define EVP_pkcs11_hcrypto_camellia_256_cbc() hc_EVP_pkcs11_hcrypto_camellia_256_cbc() HC_CPP_BEGIN /* * Strict PKCS#11 implementations (these will return NULL if the underlying * PKCS#11 implementation does not implement the cipher or hash). */ const EVP_MD * hc_EVP_pkcs11_md2(void); const EVP_MD * hc_EVP_pkcs11_md4(void); const EVP_MD * hc_EVP_pkcs11_md5(void); const EVP_MD * hc_EVP_pkcs11_sha1(void); const EVP_MD * hc_EVP_pkcs11_sha256(void); const EVP_MD * hc_EVP_pkcs11_sha384(void); const EVP_MD * hc_EVP_pkcs11_sha512(void); const EVP_CIPHER * hc_EVP_pkcs11_rc2_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_rc2_40_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_rc2_64_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_rc4(void); const EVP_CIPHER * hc_EVP_pkcs11_rc4_40(void); const EVP_CIPHER * hc_EVP_pkcs11_des_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_des_ede3_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_aes_128_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_aes_192_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_aes_256_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_aes_128_cfb8(void); const EVP_CIPHER * hc_EVP_pkcs11_aes_192_cfb8(void); const EVP_CIPHER * hc_EVP_pkcs11_aes_256_cfb8(void); const EVP_CIPHER * hc_EVP_pkcs11_camellia_128_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_camellia_192_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_camellia_256_cbc(void); /* * PKCS#11 implementations with fallback to hcrypto. */ const EVP_MD * hc_EVP_pkcs11_hcrypto_md2(void); const EVP_MD * hc_EVP_pkcs11_hcrypto_md4(void); const EVP_MD * hc_EVP_pkcs11_hcrypto_md5(void); const EVP_MD * hc_EVP_pkcs11_hcrypto_sha1(void); const EVP_MD * hc_EVP_pkcs11_hcrypto_sha256(void); const EVP_MD * hc_EVP_pkcs11_hcrypto_sha384(void); const EVP_MD * hc_EVP_pkcs11_hcrypto_sha512(void); const EVP_CIPHER * hc_EVP_pkcs11_hcrypto_rc2_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_hcrypto_rc2_40_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_hcrypto_rc2_64_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_hcrypto_rc4(void); const EVP_CIPHER * hc_EVP_pkcs11_hcrypto_rc4_40(void); const EVP_CIPHER * hc_EVP_pkcs11_hcrypto_des_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_hcrypto_des_ede3_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_hcrypto_aes_128_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_hcrypto_aes_192_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_hcrypto_aes_256_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_hcrypto_aes_128_cfb8(void); const EVP_CIPHER * hc_EVP_pkcs11_hcrypto_aes_192_cfb8(void); const EVP_CIPHER * hc_EVP_pkcs11_hcrypto_aes_256_cfb8(void); const EVP_CIPHER * hc_EVP_pkcs11_hcrypto_camellia_128_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_hcrypto_camellia_192_cbc(void); const EVP_CIPHER * hc_EVP_pkcs11_hcrypto_camellia_256_cbc(void); HC_CPP_END #endif /* HEIM_EVP_PKCS11_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/evp.h000066400000000000000000000303201505521762700232450ustar00rootroot00000000000000/* * Copyright (c) 2005 - 2016 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef HEIM_EVP_H #define HEIM_EVP_H 1 #include /* symbol renaming */ #define EVP_CIPHER_CTX_block_size hc_EVP_CIPHER_CTX_block_size #define EVP_CIPHER_CTX_cipher hc_EVP_CIPHER_CTX_cipher #define EVP_CIPHER_CTX_cleanup hc_EVP_CIPHER_CTX_cleanup #define EVP_CIPHER_CTX_flags hc_EVP_CIPHER_CTX_flags #define EVP_CIPHER_CTX_get_app_data hc_EVP_CIPHER_CTX_get_app_data #define EVP_CIPHER_CTX_init hc_EVP_CIPHER_CTX_init #define EVP_CIPHER_CTX_iv_length hc_EVP_CIPHER_CTX_iv_length #define EVP_CIPHER_CTX_key_length hc_EVP_CIPHER_CTX_key_length #define EVP_CIPHER_CTX_mode hc_EVP_CIPHER_CTX_mode #define EVP_CIPHER_CTX_set_app_data hc_EVP_CIPHER_CTX_set_app_data #define EVP_CIPHER_CTX_set_key_length hc_EVP_CIPHER_CTX_set_key_length #define EVP_CIPHER_CTX_set_padding hc_EVP_CIPHER_CTX_set_padding #define EVP_CIPHER_block_size hc_EVP_CIPHER_block_size #define EVP_CIPHER_iv_length hc_EVP_CIPHER_iv_length #define EVP_CIPHER_key_length hc_EVP_CIPHER_key_length #define EVP_Cipher hc_EVP_Cipher #define EVP_CipherInit_ex hc_EVP_CipherInit_ex #define EVP_CipherUpdate hc_EVP_CipherUpdate #define EVP_CipherFinal_ex hc_EVP_CipherFinal_ex #define EVP_Digest hc_EVP_Digest #define EVP_DigestFinal_ex hc_EVP_DigestFinal_ex #define EVP_DigestInit_ex hc_EVP_DigestInit_ex #define EVP_DigestUpdate hc_EVP_DigestUpdate #define EVP_MD_CTX_block_size hc_EVP_MD_CTX_block_size #define EVP_MD_CTX_cleanup hc_EVP_MD_CTX_cleanup #define EVP_MD_CTX_create hc_EVP_MD_CTX_create #define EVP_MD_CTX_init hc_EVP_MD_CTX_init #define EVP_MD_CTX_destroy hc_EVP_MD_CTX_destroy #define EVP_MD_CTX_md hc_EVP_MD_CTX_md #define EVP_MD_CTX_size hc_EVP_MD_CTX_size #define EVP_MD_block_size hc_EVP_MD_block_size #define EVP_MD_size hc_EVP_MD_size #define EVP_aes_128_cbc hc_EVP_aes_128_cbc #define EVP_aes_192_cbc hc_EVP_aes_192_cbc #define EVP_aes_256_cbc hc_EVP_aes_256_cbc #define EVP_aes_128_cfb8 hc_EVP_aes_128_cfb8 #define EVP_aes_192_cfb8 hc_EVP_aes_192_cfb8 #define EVP_aes_256_cfb8 hc_EVP_aes_256_cfb8 #define EVP_des_cbc hc_EVP_des_cbc #define EVP_des_ede3_cbc hc_EVP_des_ede3_cbc #define EVP_enc_null hc_EVP_enc_null #define EVP_md2 hc_EVP_md2 #define EVP_md4 hc_EVP_md4 #define EVP_md5 hc_EVP_md5 #define EVP_md_null hc_EVP_md_null #define EVP_rc2_40_cbc hc_EVP_rc2_40_cbc #define EVP_rc2_64_cbc hc_EVP_rc2_64_cbc #define EVP_rc2_cbc hc_EVP_rc2_cbc #define EVP_rc4 hc_EVP_rc4 #define EVP_rc4_40 hc_EVP_rc4_40 #define EVP_camellia_128_cbc hc_EVP_camellia_128_cbc #define EVP_camellia_192_cbc hc_EVP_camellia_192_cbc #define EVP_camellia_256_cbc hc_EVP_camellia_256_cbc #define EVP_sha hc_EVP_sha #define EVP_sha1 hc_EVP_sha1 #define EVP_sha256 hc_EVP_sha256 #define EVP_sha384 hc_EVP_sha384 #define EVP_sha512 hc_EVP_sha512 #define PKCS5_PBKDF2_HMAC hc_PKCS5_PBKDF2_HMAC #define PKCS5_PBKDF2_HMAC_SHA1 hc_PKCS5_PBKDF2_HMAC_SHA1 #define EVP_BytesToKey hc_EVP_BytesToKey #define EVP_get_cipherbyname hc_EVP_get_cipherbyname #define OpenSSL_add_all_algorithms hc_OpenSSL_add_all_algorithms #define OpenSSL_add_all_algorithms_conf hc_OpenSSL_add_all_algorithms_conf #define OpenSSL_add_all_algorithms_noconf hc_OpenSSL_add_all_algorithms_noconf #define EVP_CIPHER_CTX_ctrl hc_EVP_CIPHER_CTX_ctrl #define EVP_CIPHER_CTX_rand_key hc_EVP_CIPHER_CTX_rand_key #define hcrypto_validate hc_hcrypto_validate /* Type name renaming */ #define EVP_MD_CTX hc_EVP_MD_CTX #define EVP_PKEY hc_EVP_PKEY #define EVP_MD hc_EVP_MD #define EVP_CIPHER hc_EVP_CIPHER #define EVP_CIPHER_CTX hc_EVP_CIPHER_CTX /* Constant renaming */ #define EVP_CIPH_STREAM_CIPHER hc_EVP_CIPH_STREAM_CIPHER #define EVP_CIPH_CBC_MODE hc_EVP_CIPH_CBC_MODE #define EVP_CIPH_CFB8_MODE hc_EVP_CIPH_CFB8_MODE #define EVP_CIPH_MODE hc_EVP_CIPH_MODE #define EVP_CIPH_CTRL_INIT hc_EVP_CIPH_CTRL_INIT #define EVP_CIPH_VARIABLE_LENGTH hc_EVP_CIPH_VARIABLE_LENGTH #define EVP_CIPH_ALWAYS_CALL_INIT hc_EVP_CIPH_ALWAYS_CALL_INIT #define EVP_CIPH_RAND_KEY hc_EVP_CIPH_RAND_KEY #define EVP_CTRL_INIT hc_EVP_CTRL_INIT /* * */ typedef struct hc_EVP_MD_CTX EVP_MD_CTX; typedef struct hc_evp_pkey EVP_PKEY; typedef struct hc_evp_md EVP_MD; typedef struct hc_CIPHER EVP_CIPHER; typedef struct hc_CIPHER_CTX EVP_CIPHER_CTX; #define EVP_MAX_IV_LENGTH 16 #define EVP_MAX_BLOCK_LENGTH 32 #define EVP_MAX_MD_SIZE 64 struct hc_CIPHER { int nid; int block_size; int key_len; int iv_len; unsigned long flags; /* The lowest 3 bits is used as integer field for the mode the * cipher is used in (use EVP_CIPHER.._mode() to extract the * mode). The rest of the flag field is a bitfield. */ #define hc_EVP_CIPH_STREAM_CIPHER 0 #define hc_EVP_CIPH_CBC_MODE 2 #define hc_EVP_CIPH_CFB8_MODE 4 #define hc_EVP_CIPH_MODE 0x7 #define hc_EVP_CIPH_CTRL_INIT 0x40 #define hc_EVP_CTRL_INIT 0x0 #define hc_EVP_CIPH_VARIABLE_LENGTH 0x008 /* variable key length */ #define hc_EVP_CIPH_ALWAYS_CALL_INIT 0x020 /* backend maintains own cipherstate */ #define hc_EVP_CIPH_RAND_KEY 0x200 int (*init)(EVP_CIPHER_CTX*,const unsigned char*,const unsigned char*,int); int (*do_cipher)(EVP_CIPHER_CTX *, unsigned char *, const unsigned char *, unsigned int); int (*cleanup)(EVP_CIPHER_CTX *); int ctx_size; int (*set_asn1_parameters)(void); int (*get_asn1_parameters)(void); int (*ctrl)(EVP_CIPHER_CTX *, int type, int arg, void *ptr); #define EVP_CTRL_RAND_KEY 0x6 void *app_data; }; struct hc_CIPHER_CTX { const EVP_CIPHER *cipher; ENGINE *engine; int encrypt; int buf_len; /* bytes stored in buf for EVP_CipherUpdate */ unsigned char oiv[EVP_MAX_IV_LENGTH]; unsigned char iv[EVP_MAX_IV_LENGTH]; unsigned char buf[EVP_MAX_BLOCK_LENGTH]; int num; void *app_data; int key_len; unsigned long flags; void *cipher_data; int final_used; int block_mask; unsigned char final[EVP_MAX_BLOCK_LENGTH]; }; /* * LIES. It's not an EVP_MD_CTX that gets passed to these functions * here in hcrypto, but an object of ctx_size. */ typedef int (*hc_evp_md_init)(EVP_MD_CTX *); typedef int (*hc_evp_md_update)(EVP_MD_CTX *,const void *, size_t); typedef int (*hc_evp_md_final)(void *, EVP_MD_CTX *); typedef int (*hc_evp_md_cleanup)(EVP_MD_CTX *); struct hc_evp_md { int hash_size; int block_size; int ctx_size; hc_evp_md_init init; hc_evp_md_update update; hc_evp_md_final final; hc_evp_md_cleanup cleanup; }; #if !defined(__GNUC__) && !defined(__attribute__) #define __attribute__(x) #endif #ifndef HC_DEPRECATED #if defined(__GNUC__) && ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1 ))) #define HC_DEPRECATED __attribute__((deprecated)) #elif defined(_MSC_VER) && (_MSC_VER>1200) #define HC_DEPRECATED __declspec(deprecated) #else #define HC_DEPRECATED #endif #endif #ifndef HC_DEPRECATED_CRYPTO #define HC_DEPRECATED_CRYPTO HC_DEPRECATED #endif #ifdef __cplusplus #define HC_CPP_BEGIN extern "C" { #define HC_CPP_END } #else #define HC_CPP_BEGIN #define HC_CPP_END #endif HC_CPP_BEGIN /* * Avaible crypto algs */ const EVP_MD *EVP_md_null(void); HC_DEPRECATED_CRYPTO const EVP_MD *EVP_md2(void); HC_DEPRECATED_CRYPTO const EVP_MD *EVP_md4(void); HC_DEPRECATED_CRYPTO const EVP_MD *EVP_md5(void); const EVP_MD *EVP_sha(void); const EVP_MD *EVP_sha1(void); const EVP_MD *EVP_sha256(void); const EVP_MD *EVP_sha384(void); const EVP_MD *EVP_sha512(void); const EVP_CIPHER * EVP_aes_128_cbc(void); const EVP_CIPHER * EVP_aes_192_cbc(void); const EVP_CIPHER * EVP_aes_256_cbc(void); const EVP_CIPHER * EVP_aes_128_cfb8(void); const EVP_CIPHER * EVP_aes_192_cfb8(void); const EVP_CIPHER * EVP_aes_256_cfb8(void); HC_DEPRECATED_CRYPTO const EVP_CIPHER * EVP_des_cbc(void); const EVP_CIPHER * EVP_des_ede3_cbc(void); const EVP_CIPHER * EVP_enc_null(void); HC_DEPRECATED_CRYPTO const EVP_CIPHER * EVP_rc2_40_cbc(void); HC_DEPRECATED_CRYPTO const EVP_CIPHER * EVP_rc2_64_cbc(void); HC_DEPRECATED_CRYPTO const EVP_CIPHER * EVP_rc2_cbc(void); const EVP_CIPHER * EVP_rc4(void); HC_DEPRECATED_CRYPTO const EVP_CIPHER * EVP_rc4_40(void); const EVP_CIPHER * EVP_camellia_128_cbc(void); const EVP_CIPHER * EVP_camellia_192_cbc(void); const EVP_CIPHER * EVP_camellia_256_cbc(void); size_t EVP_MD_size(const EVP_MD *); size_t EVP_MD_block_size(const EVP_MD *); const EVP_MD * EVP_MD_CTX_md(EVP_MD_CTX *); size_t EVP_MD_CTX_size(EVP_MD_CTX *); size_t EVP_MD_CTX_block_size(EVP_MD_CTX *); EVP_MD_CTX * EVP_MD_CTX_create(void); void HC_DEPRECATED EVP_MD_CTX_init(EVP_MD_CTX *); void EVP_MD_CTX_destroy(EVP_MD_CTX *); int HC_DEPRECATED EVP_MD_CTX_cleanup(EVP_MD_CTX *); int EVP_DigestInit_ex(EVP_MD_CTX *, const EVP_MD *, ENGINE *); int EVP_DigestUpdate(EVP_MD_CTX *,const void *, size_t); int EVP_DigestFinal_ex(EVP_MD_CTX *, void *, unsigned int *); int EVP_Digest(const void *, size_t, void *, unsigned int *, const EVP_MD *, ENGINE *); /* * */ const EVP_CIPHER * EVP_get_cipherbyname(const char *); size_t EVP_CIPHER_block_size(const EVP_CIPHER *); size_t EVP_CIPHER_key_length(const EVP_CIPHER *); size_t EVP_CIPHER_iv_length(const EVP_CIPHER *); void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *); int EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *); int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *, int); int EVP_CIPHER_CTX_set_padding(EVP_CIPHER_CTX *, int); unsigned long EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *); int EVP_CIPHER_CTX_mode(const EVP_CIPHER_CTX *); const EVP_CIPHER * EVP_CIPHER_CTX_cipher(EVP_CIPHER_CTX *); size_t EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *); size_t EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *); size_t EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *); void * EVP_CIPHER_CTX_get_app_data(EVP_CIPHER_CTX *); void EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *, void *); int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *, int, int, void *); int EVP_CIPHER_CTX_rand_key(EVP_CIPHER_CTX *, void *); int EVP_CipherInit_ex(EVP_CIPHER_CTX *,const EVP_CIPHER *, ENGINE *, const void *, const void *, int); int EVP_CipherUpdate(EVP_CIPHER_CTX *, void *, int *, void *, size_t); int EVP_CipherFinal_ex(EVP_CIPHER_CTX *, void *, int *); int EVP_Cipher(EVP_CIPHER_CTX *,void *,const void *,size_t); int PKCS5_PBKDF2_HMAC(const void *, size_t, const void *, size_t, unsigned long, const EVP_MD *, size_t, void *); int PKCS5_PBKDF2_HMAC_SHA1(const void *, size_t, const void *, size_t, unsigned long, size_t, void *); int EVP_BytesToKey(const EVP_CIPHER *, const EVP_MD *, const void *, const void *, size_t, unsigned int, void *, void *); /* * */ void OpenSSL_add_all_algorithms(void); void OpenSSL_add_all_algorithms_conf(void); void OpenSSL_add_all_algorithms_noconf(void); void hcrypto_validate(void); HC_CPP_END #endif /* HEIM_EVP_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/hmac.h000066400000000000000000000052211505521762700233650ustar00rootroot00000000000000/* * Copyright (c) 2005 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef HEIM_HMAC_H #define HEIM_HMAC_H 1 #include /* symbol renaming */ #define HMAC_CTX_init hc_HMAC_CTX_init #define HMAC_CTX_cleanup hc_HMAC_CTX_cleanup #define HMAC_size hc_HMAC_size #define HMAC_Init_ex hc_HMAC_Init_ex #define HMAC_Update hc_HMAC_Update #define HMAC_Final hc_HMAC_Final #define HMAC hc_HMAC /* * */ #define HMAC_MAX_MD_CBLOCK 64 typedef struct hc_HMAC_CTX HMAC_CTX; struct hc_HMAC_CTX { const EVP_MD *md; ENGINE *engine; EVP_MD_CTX *ctx; size_t key_length; void *opad; void *ipad; void *buf; }; void HMAC_CTX_init(HMAC_CTX *); void HMAC_CTX_cleanup(HMAC_CTX *ctx); size_t HMAC_size(const HMAC_CTX *ctx); void HMAC_Init_ex(HMAC_CTX *, const void *, size_t, const EVP_MD *, ENGINE *); void HMAC_Update(HMAC_CTX *ctx, const void *data, size_t len); void HMAC_Final(HMAC_CTX *ctx, void *md, unsigned int *len); void * HMAC(const EVP_MD *evp_md, const void *key, size_t key_len, const void *data, size_t n, void *md, unsigned int *md_len); #endif /* HEIM_HMAC_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/md2.h000066400000000000000000000042641505521762700231450ustar00rootroot00000000000000/* * Copyright (c) 2006 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef HEIM_MD2_H #define HEIM_MD2_H 1 /* symbol renaming */ #define MD2_Init hc_MD2_Init #define MD2_Update hc_MD2_Update #define MD2_Final hc_MD2_Final /* * */ #define MD2_DIGEST_LENGTH 16 struct md2 { size_t len; unsigned char data[16]; /* stored unalligned data between Update's */ unsigned char checksum[16]; unsigned char state[16]; /* lower 16 bytes of X */ }; typedef struct md2 MD2_CTX; int MD2_Init (struct md2 *m); int MD2_Update (struct md2 *m, const void *p, size_t len); int MD2_Final (void *res, struct md2 *m); #endif /* HEIM_MD2_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/md4.h000066400000000000000000000041211505521762700231370ustar00rootroot00000000000000/* * Copyright (c) 1995 - 2001 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef HEIM_MD4_H #define HEIM_MD4_H 1 /* symbol renaming */ #define MD4_Init hc_MD4_Init #define MD4_Update hc_MD4_Update #define MD4_Final hc_MD4_Final /* * */ #define MD4_DIGEST_LENGTH 16 struct md4 { unsigned int sz[2]; uint32_t counter[4]; unsigned char save[64]; }; typedef struct md4 MD4_CTX; int MD4_Init (struct md4 *m); int MD4_Update (struct md4 *m, const void *p, size_t len); int MD4_Final (void *res, struct md4 *m); #endif /* HEIM_MD4_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/md5.h000066400000000000000000000041471505521762700231500ustar00rootroot00000000000000/* * Copyright (c) 1995 - 2001 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef HEIM_MD5_H #define HEIM_MD5_H 1 /* symbol renaming */ #define MD5_Init hc_MD5_Init #define MD5_Update hc_MD5_Update #define MD5_Final hc_MD5_Final /* * */ #define MD5_DIGEST_LENGTH 16 struct md5 { unsigned int sz[2]; uint32_t counter[4]; unsigned char save[64]; }; typedef struct md5 MD5_CTX; int MD5_Init (struct md5 *m); int MD5_Update (struct md5 *m, const void *p, size_t len); int MD5_Final (void *res, struct md5 *m); /* uint32_t res[4] */ #endif /* HEIM_MD5_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/pkcs12.h000066400000000000000000000037161505521762700235670ustar00rootroot00000000000000/* * Copyright (c) 2006 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * $Id$ */ #ifndef _HEIM_PKCS12_H #define _HEIM_PKCS12_H 1 /* symbol renaming */ #define PKCS12_key_gen hc_PKCS12_key_gen /* * */ #include #define PKCS12_KEY_ID 1 #define PKCS12_IV_ID 2 int PKCS12_key_gen(const void *, size_t, const void *, size_t, int, int, size_t, void *, const EVP_MD *); #endif /* _HEIM_PKCS12_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/rand.h000066400000000000000000000064561505521762700234140ustar00rootroot00000000000000 /* * Copyright (c) 2006 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * $Id$ */ #ifndef _HEIM_RAND_H #define _HEIM_RAND_H 1 #define RAND_METHOD hc_RAND_METHOD typedef struct RAND_METHOD RAND_METHOD; #include /* symbol renaming */ #define RAND_bytes hc_RAND_bytes #define RAND_pseudo_bytes hc_RAND_pseudo_bytes #define RAND_seed hc_RAND_seed #define RAND_cleanup hc_RAND_cleanup #define RAND_add hc_RAND_add #define RAND_set_rand_method hc_RAND_set_rand_method #define RAND_get_rand_method hc_RAND_get_rand_method #define RAND_set_rand_engine hc_RAND_set_rand_engine #define RAND_file_name hc_RAND_file_name #define RAND_load_file hc_RAND_load_file #define RAND_write_file hc_RAND_write_file #define RAND_status hc_RAND_status #define RAND_fortuna_method hc_RAND_fortuna_method #define RAND_unix_method hc_RAND_unix_method #define RAND_w32crypto_method hc_RAND_w32crypto_method /* * */ struct RAND_METHOD { void (*seed)(const void *, int); int (*bytes)(unsigned char *, int); void (*cleanup)(void); void (*add)(const void *, int, double); int (*pseudorand)(unsigned char *, int); int (*status)(void); }; /* * */ int RAND_bytes(void *, size_t num); int RAND_pseudo_bytes(void *, size_t); void RAND_seed(const void *, size_t); void RAND_cleanup(void); void RAND_add(const void *, size_t, double); int RAND_set_rand_method(const RAND_METHOD *); const RAND_METHOD * RAND_get_rand_method(void); int RAND_set_rand_engine(ENGINE *); const char * RAND_file_name(char *, size_t); int RAND_load_file(const char *, size_t); int RAND_write_file(const char *); int RAND_status(void); const RAND_METHOD * RAND_fortuna_method(void); const RAND_METHOD * RAND_unix_method(void); const RAND_METHOD * RAND_w32crypto_method(void); #endif /* _HEIM_RAND_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/rc2.h000066400000000000000000000045541505521762700231530ustar00rootroot00000000000000/* * Copyright (c) 2004 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ /* symbol renaming */ #define RC2_set_key hc_RC2_set_key #define RC2_encryptc hc_RC2_encryptc #define RC2_decryptc hc_RC2_decryptc #define RC2_cbc_encrypt hc_RC2_cbc_encrypt /* * */ #define RC2_ENCRYPT 1 #define RC2_DECRYPT 0 #define RC2_BLOCK_SIZE 8 #define RC2_BLOCK RC2_BLOCK_SIZE #define RC2_KEY_LENGTH 16 typedef struct rc2_key { unsigned int data[64]; } RC2_KEY; #ifdef __cplusplus extern "C" { #endif void RC2_set_key(RC2_KEY *, int, const unsigned char *,int); void RC2_encryptc(unsigned char *, unsigned char *, const RC2_KEY *); void RC2_decryptc(unsigned char *, unsigned char *, const RC2_KEY *); void RC2_cbc_encrypt(const unsigned char *, unsigned char *, long, RC2_KEY *, unsigned char *, int); #ifdef __cplusplus } #endif pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/rc4.h000066400000000000000000000036401505521762700231500ustar00rootroot00000000000000/* * Copyright (c) 2004 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ /* symbol renaming */ #define RC4_set_key hc_RC4_set_key #define RC4 hc_RC4 typedef struct rc4_key { unsigned int x, y; unsigned int state[256]; } RC4_KEY; void RC4_set_key(RC4_KEY *, const int, const unsigned char *); void RC4(RC4_KEY *, const int, const unsigned char *, unsigned char *); pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/rsa.h000066400000000000000000000133751505521762700232530ustar00rootroot00000000000000/* * Copyright (c) 2006-2016 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * $Id$ */ #ifndef _HEIM_RSA_H #define _HEIM_RSA_H 1 /* symbol renaming */ #define RSA_null_method hc_RSA_null_method #define RSA_ltm_method hc_RSA_ltm_method #define RSA_gmp_method hc_RSA_gmp_method #define RSA_tfm_method hc_RSA_tfm_method #define RSA_new hc_RSA_new #define RSA_new_method hc_RSA_new_method #define RSA_free hc_RSA_free #define RSA_up_ref hc_RSA_up_ref #define RSA_set_default_method hc_RSA_set_default_method #define RSA_get_default_method hc_RSA_get_default_method #define RSA_set_method hc_RSA_set_method #define RSA_get_method hc_RSA_get_method #define RSA_set_app_data hc_RSA_set_app_data #define RSA_get_app_data hc_RSA_get_app_data #define RSA_check_key hc_RSA_check_key #define RSA_size hc_RSA_size #define RSA_public_encrypt hc_RSA_public_encrypt #define RSA_public_decrypt hc_RSA_public_decrypt #define RSA_private_encrypt hc_RSA_private_encrypt #define RSA_private_decrypt hc_RSA_private_decrypt #define RSA_sign hc_RSA_sign #define RSA_verify hc_RSA_verify #define RSA_generate_key_ex hc_RSA_generate_key_ex #define d2i_RSAPrivateKey hc_d2i_RSAPrivateKey #define i2d_RSAPrivateKey hc_i2d_RSAPrivateKey #define i2d_RSAPublicKey hc_i2d_RSAPublicKey #define d2i_RSAPublicKey hc_d2i_RSAPublicKey #define RSA hc_RSA #define RSA_METHOD hc_RSA_METHOD /* * */ typedef struct RSA RSA; typedef struct RSA_METHOD RSA_METHOD; #include #include struct RSA_METHOD { const char *name; int (*rsa_pub_enc)(int,const unsigned char *, unsigned char *, RSA *,int); int (*rsa_pub_dec)(int,const unsigned char *, unsigned char *, RSA *,int); int (*rsa_priv_enc)(int,const unsigned char *, unsigned char *, RSA *,int); int (*rsa_priv_dec)(int,const unsigned char *, unsigned char *, RSA *,int); void *rsa_mod_exp; void *bn_mod_exp; int (*init)(RSA *rsa); int (*finish)(RSA *rsa); int flags; char *app_data; int (*rsa_sign)(int, const unsigned char *, unsigned int, unsigned char *, unsigned int *, const RSA *); int (*rsa_verify)(int, const unsigned char *, unsigned int, unsigned char *, unsigned int, const RSA *); int (*rsa_keygen)(RSA *, int, BIGNUM *, BN_GENCB *); }; struct RSA { int pad; long version; const RSA_METHOD *meth; void *engine; BIGNUM *n; BIGNUM *e; BIGNUM *d; BIGNUM *p; BIGNUM *q; BIGNUM *dmp1; BIGNUM *dmq1; BIGNUM *iqmp; struct rsa_CRYPTO_EX_DATA { void *sk; int dummy; } ex_data; int references; int flags; void *_method_mod_n; void *_method_mod_p; void *_method_mod_q; char *bignum_data; void *blinding; void *mt_blinding; }; #define RSA_FLAG_NO_BLINDING 0x0080 #define RSA_PKCS1_PADDING 1 #define RSA_PKCS1_OAEP_PADDING 4 #define RSA_PKCS1_PADDING_SIZE 11 /* * */ const RSA_METHOD *RSA_null_method(void); const RSA_METHOD *RSA_gmp_method(void); const RSA_METHOD *RSA_tfm_method(void); const RSA_METHOD *RSA_ltm_method(void); /* * */ RSA * RSA_new(void); RSA * RSA_new_method(ENGINE *); void RSA_free(RSA *); int RSA_up_ref(RSA *); void RSA_set_default_method(const RSA_METHOD *); const RSA_METHOD * RSA_get_default_method(void); const RSA_METHOD * RSA_get_method(const RSA *); int RSA_set_method(RSA *, const RSA_METHOD *); int RSA_set_app_data(RSA *, void *arg); void * RSA_get_app_data(const RSA *); int RSA_check_key(const RSA *); int RSA_size(const RSA *); int RSA_public_encrypt(int,const unsigned char*,unsigned char*,RSA *,int); int RSA_private_encrypt(int,const unsigned char*,unsigned char*,RSA *,int); int RSA_public_decrypt(int,const unsigned char*,unsigned char*,RSA *,int); int RSA_private_decrypt(int,const unsigned char*,unsigned char*,RSA *,int); int RSA_sign(int, const unsigned char *, unsigned int, unsigned char *, unsigned int *, RSA *); int RSA_verify(int, const unsigned char *, unsigned int, unsigned char *, unsigned int, RSA *); int RSA_generate_key_ex(RSA *, int, BIGNUM *, BN_GENCB *); RSA * d2i_RSAPrivateKey(RSA *, const unsigned char **, size_t); int i2d_RSAPrivateKey(RSA *, unsigned char **); int i2d_RSAPublicKey(RSA *, unsigned char **); RSA * d2i_RSAPublicKey(RSA *, const unsigned char **, size_t); #endif /* _HEIM_RSA_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/sha.h000066400000000000000000000064041505521762700232340ustar00rootroot00000000000000/* * Copyright (c) 1995 - 2001 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef HEIM_SHA_H #define HEIM_SHA_H 1 /* symbol renaming */ #define SHA1_Init hc_SHA1_Init #define SHA1_Update hc_SHA1_Update #define SHA1_Final hc_SHA1_Final #define SHA256_Init hc_SHA256_Init #define SHA256_Update hc_SHA256_Update #define SHA256_Final hc_SHA256_Final #define SHA384_Init hc_SHA384_Init #define SHA384_Update hc_SHA384_Update #define SHA384_Final hc_SHA384_Final #define SHA512_Init hc_SHA512_Init #define SHA512_Update hc_SHA512_Update #define SHA512_Final hc_SHA512_Final /* * SHA-1 */ #define SHA_DIGEST_LENGTH 20 struct sha { unsigned int sz[2]; uint32_t counter[5]; unsigned char save[64]; }; typedef struct sha SHA_CTX; int SHA1_Init (struct sha *m); int SHA1_Update (struct sha *m, const void *v, size_t len); int SHA1_Final (void *res, struct sha *m); /* * SHA-2 256 */ #define SHA256_DIGEST_LENGTH 32 struct hc_sha256state { unsigned int sz[2]; uint32_t counter[8]; unsigned char save[64]; }; typedef struct hc_sha256state SHA256_CTX; int SHA256_Init (SHA256_CTX *); int SHA256_Update (SHA256_CTX *, const void *, size_t); int SHA256_Final (void *, SHA256_CTX *); /* * SHA-2 512 */ #define SHA512_DIGEST_LENGTH 64 struct hc_sha512state { uint64_t sz[2]; uint64_t counter[8]; unsigned char save[128]; }; typedef struct hc_sha512state SHA512_CTX; int SHA512_Init (SHA512_CTX *); int SHA512_Update (SHA512_CTX *, const void *, size_t); int SHA512_Final (void *, SHA512_CTX *); #define SHA384_DIGEST_LENGTH 48 typedef struct hc_sha512state SHA384_CTX; int SHA384_Init (SHA384_CTX *); int SHA384_Update (SHA384_CTX *, const void *, size_t); int SHA384_Final (void *, SHA384_CTX *); #endif /* HEIM_SHA_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/ui.h000066400000000000000000000035141505521762700230750ustar00rootroot00000000000000/* * Copyright (c) 2005 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef _HEIM_UI_H #define _HEIM_UI_H 1 /* symbol renaming */ #define UI_UTIL_read_pw_string hc_UI_UTIL_read_pw_string int UI_UTIL_read_pw_string(char *, int, const char *, int); /* XXX */ #endif /* _HEIM_UI_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hcrypto/undef.h000066400000000000000000000107541505521762700235650ustar00rootroot00000000000000/* * Copyright (c) 2016 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef HEIM_UNDEF_H #define HEIM_UNDEF_H 1 #undef BIGNUM #undef BN_CTX #undef BN_BLINDING #undef BN_MONT_CTX #undef BN_GENCB #undef DH #undef DH_METHOD #undef DSA #undef DSA_METHOD #undef RSA #undef RSA_METHOD #undef RAND_METHOD #undef ENGINE #undef BN_GENCB_call #undef BN_GENCB_set #undef BN_CTX_new #undef BN_CTX_free #undef BN_CTX_start #undef BN_CTX_get #undef BN_CTX_end #undef BN_is_negative #undef BN_rand #undef BN_num_bits #undef BN_num_bytes #undef BN_new #undef BN_clear_free #undef BN_bin2bn #undef BN_bn2bin #undef BN_uadd #undef BN_set_negative #undef BN_set_word #undef BN_get_word #undef BN_cmp #undef BN_free #undef BN_is_bit_set #undef BN_clear #undef BN_dup #undef BN_set_bit #undef BN_clear_bit #undef BN_bn2hex #undef BN_hex2bn #undef EVP_CIPHER_CTX_block_size #undef EVP_CIPHER_CTX_cipher #undef EVP_CIPHER_CTX_cleanup #undef EVP_CIPHER_CTX_flags #undef EVP_CIPHER_CTX_get_app_data #undef EVP_CIPHER_CTX_init #undef EVP_CIPHER_CTX_iv_length #undef EVP_CIPHER_CTX_key_length #undef EVP_CIPHER_CTX_mode #undef EVP_CIPHER_CTX_set_app_data #undef EVP_CIPHER_CTX_set_key_length #undef EVP_CIPHER_CTX_set_padding #undef EVP_CIPHER_block_size #undef EVP_CIPHER_iv_length #undef EVP_CIPHER_key_length #undef EVP_Cipher #undef EVP_CipherInit_ex #undef EVP_CipherUpdate #undef EVP_CipherFinal_ex #undef EVP_Digest #undef EVP_DigestFinal_ex #undef EVP_DigestInit_ex #undef EVP_DigestUpdate #undef EVP_MD_CTX_block_size #undef EVP_MD_CTX_cleanup #undef EVP_MD_CTX_create #undef EVP_MD_CTX_init #undef EVP_MD_CTX_destroy #undef EVP_MD_CTX_md #undef EVP_MD_CTX_size #undef EVP_MD_block_size #undef EVP_MD_size #undef EVP_aes_128_cbc #undef EVP_aes_192_cbc #undef EVP_aes_256_cbc #undef EVP_aes_128_cfb8 #undef EVP_aes_192_cfb8 #undef EVP_aes_256_cfb8 #undef EVP_des_cbc #undef EVP_des_ede3_cbc #undef EVP_enc_null #undef EVP_md2 #undef EVP_md4 #undef EVP_md5 #undef EVP_md_null #undef EVP_rc2_40_cbc #undef EVP_rc2_64_cbc #undef EVP_rc2_cbc #undef EVP_rc4 #undef EVP_rc4_40 #undef EVP_camellia_128_cbc #undef EVP_camellia_192_cbc #undef EVP_camellia_256_cbc #undef EVP_sha #undef EVP_sha1 #undef EVP_sha256 #undef EVP_sha384 #undef EVP_sha512 #undef PKCS5_PBKDF2_HMAC #undef PKCS5_PBKDF2_HMAC_SHA1 #undef EVP_BytesToKey #undef EVP_get_cipherbyname #undef OpenSSL_add_all_algorithms #undef OpenSSL_add_all_algorithms_conf #undef OpenSSL_add_all_algorithms_noconf #undef EVP_CIPHER_CTX_ctrl #undef EVP_CIPHER_CTX_rand_key #undef hcrypto_validate #undef EVP_MD_CTX #undef EVP_PKEY #undef EVP_MD #undef EVP_CIPHER #undef EVP_CIPHER_CTX #undef EVP_CIPH_STREAM_CIPHER #undef EVP_CIPH_CBC_MODE #undef EVP_CIPH_CFB8_MODE #undef EVP_CIPH_MODE #undef EVP_CIPH_CTRL_INIT #undef EVP_CTRL_INIT #undef EVP_CIPH_VARIABLE_LENGTH #undef EVP_CIPH_ALWAYS_CALL_INIT #undef EVP_CIPH_RAND_KEY #undef EVP_CTRL_RAND_KEY #undef NID_md2 #undef NID_md4 #undef NID_md5 #undef NID_sha1 #undef NID_sha256 #undef NID_sha384 #undef NID_sha512 #endif /* HEIM_UNDEF_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hdb-protos.h000066400000000000000000000261271505521762700230560ustar00rootroot00000000000000/* This is a generated file */ #ifndef __hdb_protos_h__ #define __hdb_protos_h__ #ifndef DOXY #include #ifdef __cplusplus extern "C" { #endif krb5_error_code entry2mit_string_int ( krb5_context /*context*/, krb5_storage */*sp*/, hdb_entry */*ent*/); /** * This function adds an HDB entry's current keyset to the entry's key * history. The current keyset is left alone; the caller is responsible * for freeing it. * * @param context Context * @param entry HDB entry */ krb5_error_code hdb_add_current_keys_to_history ( krb5_context /*context*/, hdb_entry */*entry*/); /** * This function adds a key to an HDB entry's key history. * * @param context Context * @param entry HDB entry * @param kvno Key version number of the key to add to the history * @param key The Key to add */ krb5_error_code hdb_add_history_key ( krb5_context /*context*/, hdb_entry */*entry*/, krb5_kvno /*kvno*/, Key */*key*/); krb5_error_code hdb_add_master_key ( krb5_context /*context*/, krb5_keyblock */*key*/, hdb_master_key */*inout*/); /** * This function changes an hdb_entry's kvno, swapping the current key * set with a historical keyset. If no historical keys are found then * an error is returned (the caller can still set entry->kvno directly). * * @param context krb5_context * @param new_kvno New kvno for the entry * @param entry hdb_entry to modify */ krb5_error_code hdb_change_kvno ( krb5_context /*context*/, krb5_kvno /*new_kvno*/, hdb_entry */*entry*/); krb5_error_code hdb_check_db_format ( krb5_context /*context*/, HDB */*db*/); krb5_error_code hdb_clear_extension ( krb5_context /*context*/, hdb_entry */*entry*/, int /*type*/); krb5_error_code hdb_clear_master_key ( krb5_context /*context*/, HDB */*db*/); /** * Create a handle for a Kerberos database * * Create a handle for a Kerberos database backend specified by a * filename. Doesn't create a file if its doesn't exists, you have to * use O_CREAT to tell the backend to create the file. */ krb5_error_code hdb_create ( krb5_context /*context*/, HDB **/*db*/, const char */*filename*/); krb5_error_code hdb_db1_create ( krb5_context /*context*/, HDB **/*db*/, const char */*filename*/); krb5_error_code hdb_db3_create ( krb5_context /*context*/, HDB **/*db*/, const char */*filename*/); /** * Return the directory where the hdb database resides. * * @param context Kerberos 5 context. * * @return string pointing to directory. */ const char * hdb_db_dir (krb5_context /*context*/); const char * hdb_dbinfo_get_acl_file ( krb5_context /*context*/, struct hdb_dbinfo */*dbp*/); const krb5_config_binding * hdb_dbinfo_get_binding ( krb5_context /*context*/, struct hdb_dbinfo */*dbp*/); const char * hdb_dbinfo_get_dbname ( krb5_context /*context*/, struct hdb_dbinfo */*dbp*/); const char * hdb_dbinfo_get_label ( krb5_context /*context*/, struct hdb_dbinfo */*dbp*/); const char * hdb_dbinfo_get_log_file ( krb5_context /*context*/, struct hdb_dbinfo */*dbp*/); const char * hdb_dbinfo_get_mkey_file ( krb5_context /*context*/, struct hdb_dbinfo */*dbp*/); struct hdb_dbinfo * hdb_dbinfo_get_next ( struct hdb_dbinfo */*dbp*/, struct hdb_dbinfo */*dbprevp*/); const char * hdb_dbinfo_get_realm ( krb5_context /*context*/, struct hdb_dbinfo */*dbp*/); /** * Return the default hdb database resides. * * @param context Kerberos 5 context. * * @return string pointing to directory. */ const char * hdb_default_db (krb5_context /*context*/); krb5_error_code hdb_enctype2key ( krb5_context /*context*/, hdb_entry */*e*/, const Keys */*keyset*/, krb5_enctype /*enctype*/, Key **/*key*/); krb5_error_code hdb_entry2string ( krb5_context /*context*/, hdb_entry */*ent*/, char **/*str*/); int hdb_entry2value ( krb5_context /*context*/, const hdb_entry */*ent*/, krb5_data */*value*/); int hdb_entry_alias2value ( krb5_context /*context*/, const hdb_entry_alias */*alias*/, krb5_data */*value*/); krb5_error_code hdb_entry_check_mandatory ( krb5_context /*context*/, const hdb_entry */*ent*/); krb5_error_code hdb_entry_clear_kvno_diff_clnt ( krb5_context /*context*/, hdb_entry */*entry*/); krb5_error_code hdb_entry_clear_kvno_diff_svc ( krb5_context /*context*/, hdb_entry */*entry*/); int hdb_entry_clear_password ( krb5_context /*context*/, hdb_entry */*entry*/); krb5_error_code hdb_entry_get_ConstrainedDelegACL ( const hdb_entry */*entry*/, const HDB_Ext_Constrained_delegation_acl **/*a*/); krb5_error_code hdb_entry_get_aliases ( const hdb_entry */*entry*/, const HDB_Ext_Aliases **/*a*/); unsigned int hdb_entry_get_kvno_diff_clnt (const hdb_entry */*entry*/); unsigned int hdb_entry_get_kvno_diff_svc (const hdb_entry */*entry*/); int hdb_entry_get_password ( krb5_context /*context*/, HDB */*db*/, const hdb_entry */*entry*/, char **/*p*/); krb5_error_code hdb_entry_get_pkinit_acl ( const hdb_entry */*entry*/, const HDB_Ext_PKINIT_acl **/*a*/); krb5_error_code hdb_entry_get_pkinit_cert ( const hdb_entry */*entry*/, const HDB_Ext_PKINIT_cert **/*a*/); krb5_error_code hdb_entry_get_pkinit_hash ( const hdb_entry */*entry*/, const HDB_Ext_PKINIT_hash **/*a*/); krb5_error_code hdb_entry_get_pw_change_time ( const hdb_entry */*entry*/, time_t */*t*/); krb5_error_code hdb_entry_set_kvno_diff_clnt ( krb5_context /*context*/, hdb_entry */*entry*/, unsigned int /*diff*/); krb5_error_code hdb_entry_set_kvno_diff_svc ( krb5_context /*context*/, hdb_entry */*entry*/, unsigned int /*diff*/); int hdb_entry_set_password ( krb5_context /*context*/, HDB */*db*/, hdb_entry */*entry*/, const char */*p*/); krb5_error_code hdb_entry_set_pw_change_time ( krb5_context /*context*/, hdb_entry */*entry*/, time_t /*t*/); HDB_extension * hdb_find_extension ( const hdb_entry */*entry*/, int /*type*/); krb5_error_code hdb_foreach ( krb5_context /*context*/, HDB */*db*/, unsigned /*flags*/, hdb_foreach_func_t /*func*/, void */*data*/); void hdb_free_dbinfo ( krb5_context /*context*/, struct hdb_dbinfo **/*dbp*/); void hdb_free_entry ( krb5_context /*context*/, hdb_entry_ex */*ent*/); void hdb_free_key (Key */*key*/); void hdb_free_keys ( krb5_context /*context*/, int /*len*/, Key */*keys*/); void hdb_free_master_key ( krb5_context /*context*/, hdb_master_key /*mkey*/); krb5_error_code hdb_generate_key_set ( krb5_context /*context*/, krb5_principal /*principal*/, krb5_key_salt_tuple */*ks_tuple*/, int /*n_ks_tuple*/, Key **/*ret_key_set*/, size_t */*nkeyset*/, int /*no_salt*/); krb5_error_code hdb_generate_key_set_password ( krb5_context /*context*/, krb5_principal /*principal*/, const char */*password*/, Key **/*keys*/, size_t */*num_keys*/); krb5_error_code hdb_generate_key_set_password_with_ks_tuple ( krb5_context /*context*/, krb5_principal /*principal*/, const char */*password*/, krb5_key_salt_tuple */*ks_tuple*/, int /*n_ks_tuple*/, Key **/*keys*/, size_t */*num_keys*/); int hdb_get_dbinfo ( krb5_context /*context*/, struct hdb_dbinfo **/*dbp*/); krb5_error_code hdb_init_db ( krb5_context /*context*/, HDB */*db*/); int hdb_key2principal ( krb5_context /*context*/, krb5_data */*key*/, krb5_principal /*p*/); krb5_error_code hdb_keytab_create ( krb5_context /*context*/, HDB ** /*db*/, const char */*arg*/); const Keys * hdb_kvno2keys ( krb5_context /*context*/, const hdb_entry */*e*/, krb5_kvno /*kvno*/); krb5_error_code hdb_ldap_create ( krb5_context /*context*/, HDB ** /*db*/, const char */*arg*/); krb5_error_code hdb_ldapi_create ( krb5_context /*context*/, HDB ** /*db*/, const char */*arg*/); krb5_error_code hdb_list_builtin ( krb5_context /*context*/, char **/*list*/); krb5_error_code hdb_lock ( int /*fd*/, int /*operation*/); krb5_error_code hdb_mdb_create ( krb5_context /*context*/, HDB **/*db*/, const char */*filename*/); krb5_error_code hdb_mitdb_create ( krb5_context /*context*/, HDB **/*db*/, const char */*filename*/); krb5_error_code hdb_ndbm_create ( krb5_context /*context*/, HDB **/*db*/, const char */*filename*/); krb5_error_code hdb_next_enctype2key ( krb5_context /*context*/, const hdb_entry */*e*/, const Keys */*keyset*/, krb5_enctype /*enctype*/, Key **/*key*/); int hdb_principal2key ( krb5_context /*context*/, krb5_const_principal /*p*/, krb5_data */*key*/); krb5_error_code hdb_print_entry ( krb5_context /*context*/, HDB */*db*/, hdb_entry_ex */*entry*/, void */*data*/); krb5_error_code hdb_process_master_key ( krb5_context /*context*/, int /*kvno*/, krb5_keyblock */*key*/, krb5_enctype /*etype*/, hdb_master_key */*mkey*/); /** * This function prunes an HDB entry's keys that are too old to have been used * to mint still valid tickets (based on the entry's maximum ticket lifetime). * * @param context Context * @param entry HDB entry */ krb5_error_code hdb_prune_keys ( krb5_context /*context*/, hdb_entry */*entry*/); krb5_error_code hdb_read_master_key ( krb5_context /*context*/, const char */*filename*/, hdb_master_key */*mkey*/); krb5_error_code hdb_replace_extension ( krb5_context /*context*/, hdb_entry */*entry*/, const HDB_extension */*ext*/); krb5_error_code hdb_seal_key ( krb5_context /*context*/, HDB */*db*/, Key */*k*/); krb5_error_code hdb_seal_key_mkey ( krb5_context /*context*/, Key */*k*/, hdb_master_key /*mkey*/); krb5_error_code hdb_seal_keys ( krb5_context /*context*/, HDB */*db*/, hdb_entry */*ent*/); krb5_error_code hdb_seal_keys_mkey ( krb5_context /*context*/, hdb_entry */*ent*/, hdb_master_key /*mkey*/); krb5_error_code hdb_set_last_modified_by ( krb5_context /*context*/, hdb_entry */*entry*/, krb5_principal /*modby*/, time_t /*modtime*/); krb5_error_code hdb_set_master_key ( krb5_context /*context*/, HDB */*db*/, krb5_keyblock */*key*/); krb5_error_code hdb_set_master_keyfile ( krb5_context /*context*/, HDB */*db*/, const char */*keyfile*/); /** * Create SQLITE object, and creates the on disk database if its doesn't exists. * * @param context A Kerberos 5 context. * @param db a returned database handle. * @param filename filename * * @return 0 on success, an error code if not */ krb5_error_code hdb_sqlite_create ( krb5_context /*context*/, HDB **/*db*/, const char */*filename*/); krb5_error_code hdb_unlock (int /*fd*/); krb5_error_code hdb_unseal_key ( krb5_context /*context*/, HDB */*db*/, Key */*k*/); krb5_error_code hdb_unseal_key_mkey ( krb5_context /*context*/, Key */*k*/, hdb_master_key /*mkey*/); krb5_error_code hdb_unseal_keys ( krb5_context /*context*/, HDB */*db*/, hdb_entry */*ent*/); krb5_error_code hdb_unseal_keys_kvno ( krb5_context /*context*/, HDB */*db*/, krb5_kvno /*kvno*/, unsigned /*flags*/, hdb_entry */*ent*/); krb5_error_code hdb_unseal_keys_mkey ( krb5_context /*context*/, hdb_entry */*ent*/, hdb_master_key /*mkey*/); int hdb_value2entry ( krb5_context /*context*/, krb5_data */*value*/, hdb_entry */*ent*/); int hdb_value2entry_alias ( krb5_context /*context*/, krb5_data */*value*/, hdb_entry_alias */*ent*/); krb5_error_code hdb_write_master_key ( krb5_context /*context*/, const char */*filename*/, hdb_master_key /*mkey*/); #ifdef __cplusplus } #endif #endif /* DOXY */ #endif /* __hdb_protos_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/hdb.h000066400000000000000000000256451505521762700215360ustar00rootroot00000000000000/* * Copyright (c) 1997 - 2007 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef __HDB_H__ #define __HDB_H__ #include #include #include #include #include struct hdb_dbinfo; enum hdb_lockop{ HDB_RLOCK, HDB_WLOCK }; /* flags for various functions */ #define HDB_F_DECRYPT 1 /* decrypt keys */ #define HDB_F_REPLACE 2 /* replace entry */ #define HDB_F_GET_CLIENT 4 /* fetch client */ #define HDB_F_GET_SERVER 8 /* fetch server */ #define HDB_F_GET_KRBTGT 16 /* fetch krbtgt */ #define HDB_F_GET_ANY 28 /* fetch any of client,server,krbtgt */ #define HDB_F_CANON 32 /* want canonicalition */ #define HDB_F_ADMIN_DATA 64 /* want data that kdc don't use */ #define HDB_F_KVNO_SPECIFIED 128 /* we want a particular KVNO */ #define HDB_F_CURRENT_KVNO 256 /* we want the current KVNO */ #define HDB_F_LIVE_CLNT_KVNOS 512 /* we want all live keys for pre-auth */ #define HDB_F_LIVE_SVC_KVNOS 1024 /* we want all live keys for tix */ #define HDB_F_ALL_KVNOS 2048 /* we want all the keys, live or not */ #define HDB_F_FOR_AS_REQ 4096 /* fetch is for a AS REQ */ #define HDB_F_FOR_TGS_REQ 8192 /* fetch is for a TGS REQ */ #define HDB_F_PRECHECK 16384 /* check that the operation would succeed */ /* hdb_capability_flags */ #define HDB_CAP_F_HANDLE_ENTERPRISE_PRINCIPAL 1 #define HDB_CAP_F_HANDLE_PASSWORDS 2 #define HDB_CAP_F_PASSWORD_UPDATE_KEYS 4 #define HDB_CAP_F_SHARED_DIRECTORY 8 /* auth status values */ #define HDB_AUTH_SUCCESS 0 #define HDB_AUTH_WRONG_PASSWORD 1 #define HDB_AUTH_INVALID_SIGNATURE 2 /* key usage for master key */ #define HDB_KU_MKEY 0x484442 typedef struct hdb_master_key_data *hdb_master_key; /** * hdb_entry_ex is a wrapper structure around the hdb_entry structure * that allows backends to keep a pointer to the backing store, ie in * ->hdb_fetch_kvno(), so that we the kadmin/kpasswd backend gets around to * ->hdb_store(), the backend doesn't need to lookup the entry again. */ typedef struct hdb_entry_ex { void *ctx; hdb_entry entry; void (*free_entry)(krb5_context, struct hdb_entry_ex *); } hdb_entry_ex; /** * HDB backend function pointer structure * * The HDB structure is what the KDC and kadmind framework uses to * query the backend database when talking about principals. */ typedef struct HDB { void *hdb_db; void *hdb_dbc; /** don't use, only for DB3 */ char *hdb_name; int hdb_master_key_set; hdb_master_key hdb_master_key; int hdb_openp; int hdb_capability_flags; int lock_count; int lock_type; /** * Open (or create) the a Kerberos database. * * Open (or create) the a Kerberos database that was resolved with * hdb_create(). The third and fourth flag to the function are the * same as open(), thus passing O_CREAT will create the data base * if it doesn't exists. * * Then done the caller should call hdb_close(), and to release * all resources hdb_destroy(). */ krb5_error_code (*hdb_open)(krb5_context, struct HDB*, int, mode_t); /** * Close the database for transaction * * Closes the database for further transactions, wont release any * permanant resources. the database can be ->hdb_open-ed again. */ krb5_error_code (*hdb_close)(krb5_context, struct HDB*); /** * Free an entry after use. */ void (*hdb_free)(krb5_context, struct HDB*, hdb_entry_ex*); /** * Fetch an entry from the backend * * Fetch an entry from the backend, flags are what type of entry * should be fetch: client, server, krbtgt. * knvo (if specified and flags HDB_F_KVNO_SPECIFIED set) is the kvno to get */ krb5_error_code (*hdb_fetch_kvno)(krb5_context, struct HDB*, krb5_const_principal, unsigned, krb5_kvno, hdb_entry_ex*); /** * Store an entry to database */ krb5_error_code (*hdb_store)(krb5_context, struct HDB*, unsigned, hdb_entry_ex*); /** * Remove an entry from the database. */ krb5_error_code (*hdb_remove)(krb5_context, struct HDB*, unsigned, krb5_const_principal); /** * As part of iteration, fetch one entry */ krb5_error_code (*hdb_firstkey)(krb5_context, struct HDB*, unsigned, hdb_entry_ex*); /** * As part of iteration, fetch next entry */ krb5_error_code (*hdb_nextkey)(krb5_context, struct HDB*, unsigned, hdb_entry_ex*); /** * Lock database * * A lock can only be held by one consumers. Transaction can still * happen on the database while the lock is held, so the entry is * only useful for syncroning creation of the database and renaming of the database. */ krb5_error_code (*hdb_lock)(krb5_context, struct HDB*, int); /** * Unlock database */ krb5_error_code (*hdb_unlock)(krb5_context, struct HDB*); /** * Rename the data base. * * Assume that the database is not hdb_open'ed and not locked. */ krb5_error_code (*hdb_rename)(krb5_context, struct HDB*, const char*); /** * Get an hdb_entry from a classical DB backend * * This function takes a principal key (krb5_data) and returns all * data related to principal in the return krb5_data. The returned * encoded entry is of type hdb_entry or hdb_entry_alias. */ krb5_error_code (*hdb__get)(krb5_context, struct HDB*, krb5_data, krb5_data*); /** * Store an hdb_entry from a classical DB backend * * This function takes a principal key (krb5_data) and encoded * hdb_entry or hdb_entry_alias as the data to store. * * For a file-based DB, this must synchronize to disk when done. * This is sub-optimal for kadm5_s_rename_principal(), and for * kadm5_s_modify_principal() when using principal aliases; to * improve this so that only one fsync() need be done * per-transaction will require HDB API extensions. */ krb5_error_code (*hdb__put)(krb5_context, struct HDB*, int, krb5_data, krb5_data); /** * Delete and hdb_entry from a classical DB backend * * This function takes a principal key (krb5_data) naming the record * to delete. * * Same discussion as in @ref HDB::hdb__put */ krb5_error_code (*hdb__del)(krb5_context, struct HDB*, krb5_data); /** * Destroy the handle to the database. * * Destroy the handle to the database, deallocate all memory and * related resources. Does not remove any permanent data. Its the * logical reverse of hdb_create() function that is the entry * point for the module. */ krb5_error_code (*hdb_destroy)(krb5_context, struct HDB*); /** * Get the list of realms this backend handles. * This call is optional to support. The returned realms are used * for announcing the realms over bonjour. Free returned array * with krb5_free_host_realm(). */ krb5_error_code (*hdb_get_realms)(krb5_context, struct HDB *, krb5_realm **); /** * Change password. * * Will update keys for the entry when given password. The new * keys must be written into the entry and will then later be * ->hdb_store() into the database. The backend will still perform * all other operations, increasing the kvno, and update * modification timestamp. * * The backend needs to call _kadm5_set_keys() and perform password * quality checks. */ krb5_error_code (*hdb_password)(krb5_context, struct HDB*, hdb_entry_ex*, const char *, int); /** * Auth feedback * * This is a feedback call that allows backends that provides * lockout functionality to register failure and/or successes. * * In case the entry is locked out, the backend should set the * hdb_entry.flags.locked-out flag. */ krb5_error_code (*hdb_auth_status)(krb5_context, struct HDB *, hdb_entry_ex *, int); /** * Check if delegation is allowed. */ krb5_error_code (*hdb_check_constrained_delegation)(krb5_context, struct HDB *, hdb_entry_ex *, krb5_const_principal); /** * Check if this name is an alias for the supplied client for PKINIT userPrinicpalName logins */ krb5_error_code (*hdb_check_pkinit_ms_upn_match)(krb5_context, struct HDB *, hdb_entry_ex *, krb5_const_principal); /** * Check if s4u2self is allowed from this client to this server */ krb5_error_code (*hdb_check_s4u2self)(krb5_context, struct HDB *, hdb_entry_ex *, krb5_const_principal); /** * Enable/disable synchronous updates * * Calling this with 0 disables sync. Calling it with non-zero enables * sync and does an fsync(). */ krb5_error_code (*hdb_set_sync)(krb5_context, struct HDB *, int); }HDB; #define HDB_INTERFACE_VERSION 10 struct hdb_method { int version; krb5_error_code (*init)(krb5_context, void **); void (*fini)(void *); const char *prefix; krb5_error_code (*create)(krb5_context, HDB **, const char *filename); }; /* dump entry format, for hdb_print_entry() */ typedef enum hdb_dump_format { HDB_DUMP_HEIMDAL = 0, HDB_DUMP_MIT = 1, } hdb_dump_format_t; struct hdb_print_entry_arg { FILE *out; hdb_dump_format_t fmt; }; typedef krb5_error_code (*hdb_foreach_func_t)(krb5_context, HDB*, hdb_entry_ex*, void*); extern krb5_kt_ops hdb_kt_ops; extern krb5_kt_ops hdb_get_kt_ops; extern const int hdb_interface_version; #include #endif /* __HDB_H__ */ pykrb5-0.8.0/build_helpers/heimdal/include/hdb_asn1.h000066400000000000000000000454611505521762700224560ustar00rootroot00000000000000/* Generated from ./hdb.asn1 */ /* Do not edit */ #ifndef __hdb_asn1_h__ #define __hdb_asn1_h__ #include #include #ifndef __asn1_common_definitions__ #define __asn1_common_definitions__ #ifndef __HEIM_BASE_DATA__ #define __HEIM_BASE_DATA__ 1 struct heim_base_data { size_t length; void *data; }; typedef struct heim_base_data heim_octet_string; #endif typedef struct heim_integer { size_t length; void *data; int negative; } heim_integer; typedef char *heim_general_string; typedef char *heim_utf8_string; typedef struct heim_base_data heim_printable_string; typedef struct heim_base_data heim_ia5_string; typedef struct heim_bmp_string { size_t length; uint16_t *data; } heim_bmp_string; typedef struct heim_universal_string { size_t length; uint32_t *data; } heim_universal_string; typedef char *heim_visible_string; typedef struct heim_oid { size_t length; unsigned *components; } heim_oid; typedef struct heim_bit_string { size_t length; void *data; } heim_bit_string; typedef struct heim_base_data heim_any; typedef struct heim_base_data heim_any_set; #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \ do { \ (BL) = length_##T((S)); \ (B) = malloc((BL)); \ if((B) == NULL) { \ (R) = ENOMEM; \ } else { \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (S), (L)); \ if((R) != 0) { \ free((B)); \ (B) = NULL; \ } \ } \ } while (0) #ifdef _WIN32 #ifndef ASN1_LIB #define ASN1EXP __declspec(dllimport) #else #define ASN1EXP #endif #define ASN1CALL __stdcall #else #define ASN1EXP #define ASN1CALL #endif struct units; #endif #include enum { HDB_DB_FORMAT = 2 }; enum { hdb_pw_salt = 3 }; enum { hdb_afs3_salt = 10 }; /* Salt ::= SEQUENCE { type [0] INTEGER (0..4294967295), salt [1] OCTET STRING, opaque [2] OCTET STRING OPTIONAL, } */ typedef struct Salt { unsigned int type; heim_octet_string salt; heim_octet_string *opaque; } Salt; ASN1EXP int ASN1CALL decode_Salt(const unsigned char *, size_t, Salt *, size_t *); ASN1EXP int ASN1CALL encode_Salt(unsigned char *, size_t, const Salt *, size_t *); ASN1EXP size_t ASN1CALL length_Salt(const Salt *); ASN1EXP int ASN1CALL copy_Salt (const Salt *, Salt *); ASN1EXP void ASN1CALL free_Salt (Salt *); /* Key ::= SEQUENCE { mkvno [0] INTEGER (0..4294967295) OPTIONAL, key [1] EncryptionKey, salt [2] Salt OPTIONAL, } */ typedef struct Key { unsigned int *mkvno; EncryptionKey key; Salt *salt; } Key; ASN1EXP int ASN1CALL decode_Key(const unsigned char *, size_t, Key *, size_t *); ASN1EXP int ASN1CALL encode_Key(unsigned char *, size_t, const Key *, size_t *); ASN1EXP size_t ASN1CALL length_Key(const Key *); ASN1EXP int ASN1CALL copy_Key (const Key *, Key *); ASN1EXP void ASN1CALL free_Key (Key *); /* Event ::= SEQUENCE { time [0] KerberosTime, principal [1] Principal OPTIONAL, } */ typedef struct Event { KerberosTime time; Principal *principal; } Event; ASN1EXP int ASN1CALL decode_Event(const unsigned char *, size_t, Event *, size_t *); ASN1EXP int ASN1CALL encode_Event(unsigned char *, size_t, const Event *, size_t *); ASN1EXP size_t ASN1CALL length_Event(const Event *); ASN1EXP int ASN1CALL copy_Event (const Event *, Event *); ASN1EXP void ASN1CALL free_Event (Event *); /* HDBFlags ::= BIT STRING { initial(0), forwardable(1), proxiable(2), renewable(3), postdate(4), server(5), client(6), invalid(7), require-preauth(8), change-pw(9), require-hwauth(10), ok-as-delegate(11), user-to-user(12), immutable(13), trusted-for-delegation(14), allow-kerberos4(15), allow-digest(16), locked-out(17), require-pwchange(18), do-not-store(31) } */ typedef struct HDBFlags { unsigned int initial:1; unsigned int forwardable:1; unsigned int proxiable:1; unsigned int renewable:1; unsigned int postdate:1; unsigned int server:1; unsigned int client:1; unsigned int invalid:1; unsigned int require_preauth:1; unsigned int change_pw:1; unsigned int require_hwauth:1; unsigned int ok_as_delegate:1; unsigned int user_to_user:1; unsigned int immutable:1; unsigned int trusted_for_delegation:1; unsigned int allow_kerberos4:1; unsigned int allow_digest:1; unsigned int locked_out:1; unsigned int require_pwchange:1; unsigned int _unused19:1; unsigned int _unused20:1; unsigned int _unused21:1; unsigned int _unused22:1; unsigned int _unused23:1; unsigned int _unused24:1; unsigned int _unused25:1; unsigned int _unused26:1; unsigned int _unused27:1; unsigned int _unused28:1; unsigned int _unused29:1; unsigned int _unused30:1; unsigned int do_not_store:1; } HDBFlags; unsigned HDBFlags2int(HDBFlags); HDBFlags int2HDBFlags(unsigned); const struct units * asn1_HDBFlags_units(void); ASN1EXP int ASN1CALL decode_HDBFlags(const unsigned char *, size_t, HDBFlags *, size_t *); ASN1EXP int ASN1CALL encode_HDBFlags(unsigned char *, size_t, const HDBFlags *, size_t *); ASN1EXP size_t ASN1CALL length_HDBFlags(const HDBFlags *); ASN1EXP int ASN1CALL copy_HDBFlags (const HDBFlags *, HDBFlags *); ASN1EXP void ASN1CALL free_HDBFlags (HDBFlags *); /* GENERATION ::= SEQUENCE { time [0] KerberosTime, usec [1] INTEGER (0..4294967295), gen [2] INTEGER (0..4294967295), } */ typedef struct GENERATION { KerberosTime time; unsigned int usec; unsigned int gen; } GENERATION; ASN1EXP int ASN1CALL decode_GENERATION(const unsigned char *, size_t, GENERATION *, size_t *); ASN1EXP int ASN1CALL encode_GENERATION(unsigned char *, size_t, const GENERATION *, size_t *); ASN1EXP size_t ASN1CALL length_GENERATION(const GENERATION *); ASN1EXP int ASN1CALL copy_GENERATION (const GENERATION *, GENERATION *); ASN1EXP void ASN1CALL free_GENERATION (GENERATION *); /* HDB-Ext-PKINIT-acl ::= SEQUENCE OF SEQUENCE { subject [0] UTF8String, issuer [1] UTF8String OPTIONAL, anchor [2] UTF8String OPTIONAL, } */ typedef struct HDB_Ext_PKINIT_acl { unsigned int len; struct HDB_Ext_PKINIT_acl_val { heim_utf8_string subject; heim_utf8_string *issuer; heim_utf8_string *anchor; } *val; } HDB_Ext_PKINIT_acl; ASN1EXP int ASN1CALL decode_HDB_Ext_PKINIT_acl(const unsigned char *, size_t, HDB_Ext_PKINIT_acl *, size_t *); ASN1EXP int ASN1CALL encode_HDB_Ext_PKINIT_acl(unsigned char *, size_t, const HDB_Ext_PKINIT_acl *, size_t *); ASN1EXP size_t ASN1CALL length_HDB_Ext_PKINIT_acl(const HDB_Ext_PKINIT_acl *); ASN1EXP int ASN1CALL copy_HDB_Ext_PKINIT_acl (const HDB_Ext_PKINIT_acl *, HDB_Ext_PKINIT_acl *); ASN1EXP void ASN1CALL free_HDB_Ext_PKINIT_acl (HDB_Ext_PKINIT_acl *); /* HDB-Ext-PKINIT-hash ::= SEQUENCE OF SEQUENCE { digest-type [0] OBJECT IDENTIFIER, digest [1] OCTET STRING, } */ typedef struct HDB_Ext_PKINIT_hash { unsigned int len; struct HDB_Ext_PKINIT_hash_val { heim_oid digest_type; heim_octet_string digest; } *val; } HDB_Ext_PKINIT_hash; ASN1EXP int ASN1CALL decode_HDB_Ext_PKINIT_hash(const unsigned char *, size_t, HDB_Ext_PKINIT_hash *, size_t *); ASN1EXP int ASN1CALL encode_HDB_Ext_PKINIT_hash(unsigned char *, size_t, const HDB_Ext_PKINIT_hash *, size_t *); ASN1EXP size_t ASN1CALL length_HDB_Ext_PKINIT_hash(const HDB_Ext_PKINIT_hash *); ASN1EXP int ASN1CALL copy_HDB_Ext_PKINIT_hash (const HDB_Ext_PKINIT_hash *, HDB_Ext_PKINIT_hash *); ASN1EXP void ASN1CALL free_HDB_Ext_PKINIT_hash (HDB_Ext_PKINIT_hash *); /* HDB-Ext-PKINIT-cert ::= SEQUENCE OF SEQUENCE { cert [0] OCTET STRING, } */ typedef struct HDB_Ext_PKINIT_cert { unsigned int len; struct HDB_Ext_PKINIT_cert_val { heim_octet_string cert; } *val; } HDB_Ext_PKINIT_cert; ASN1EXP int ASN1CALL decode_HDB_Ext_PKINIT_cert(const unsigned char *, size_t, HDB_Ext_PKINIT_cert *, size_t *); ASN1EXP int ASN1CALL encode_HDB_Ext_PKINIT_cert(unsigned char *, size_t, const HDB_Ext_PKINIT_cert *, size_t *); ASN1EXP size_t ASN1CALL length_HDB_Ext_PKINIT_cert(const HDB_Ext_PKINIT_cert *); ASN1EXP int ASN1CALL copy_HDB_Ext_PKINIT_cert (const HDB_Ext_PKINIT_cert *, HDB_Ext_PKINIT_cert *); ASN1EXP void ASN1CALL free_HDB_Ext_PKINIT_cert (HDB_Ext_PKINIT_cert *); /* HDB-Ext-Constrained-delegation-acl ::= SEQUENCE OF Principal */ typedef struct HDB_Ext_Constrained_delegation_acl { unsigned int len; Principal *val; } HDB_Ext_Constrained_delegation_acl; ASN1EXP int ASN1CALL decode_HDB_Ext_Constrained_delegation_acl(const unsigned char *, size_t, HDB_Ext_Constrained_delegation_acl *, size_t *); ASN1EXP int ASN1CALL encode_HDB_Ext_Constrained_delegation_acl(unsigned char *, size_t, const HDB_Ext_Constrained_delegation_acl *, size_t *); ASN1EXP size_t ASN1CALL length_HDB_Ext_Constrained_delegation_acl(const HDB_Ext_Constrained_delegation_acl *); ASN1EXP int ASN1CALL copy_HDB_Ext_Constrained_delegation_acl (const HDB_Ext_Constrained_delegation_acl *, HDB_Ext_Constrained_delegation_acl *); ASN1EXP void ASN1CALL free_HDB_Ext_Constrained_delegation_acl (HDB_Ext_Constrained_delegation_acl *); /* HDB-Ext-Lan-Manager-OWF ::= OCTET STRING */ typedef heim_octet_string HDB_Ext_Lan_Manager_OWF; ASN1EXP int ASN1CALL decode_HDB_Ext_Lan_Manager_OWF(const unsigned char *, size_t, HDB_Ext_Lan_Manager_OWF *, size_t *); ASN1EXP int ASN1CALL encode_HDB_Ext_Lan_Manager_OWF(unsigned char *, size_t, const HDB_Ext_Lan_Manager_OWF *, size_t *); ASN1EXP size_t ASN1CALL length_HDB_Ext_Lan_Manager_OWF(const HDB_Ext_Lan_Manager_OWF *); ASN1EXP int ASN1CALL copy_HDB_Ext_Lan_Manager_OWF (const HDB_Ext_Lan_Manager_OWF *, HDB_Ext_Lan_Manager_OWF *); ASN1EXP void ASN1CALL free_HDB_Ext_Lan_Manager_OWF (HDB_Ext_Lan_Manager_OWF *); /* HDB-Ext-Password ::= SEQUENCE { mkvno [0] INTEGER (0..4294967295) OPTIONAL, password OCTET STRING, } */ typedef struct HDB_Ext_Password { unsigned int *mkvno; heim_octet_string password; } HDB_Ext_Password; ASN1EXP int ASN1CALL decode_HDB_Ext_Password(const unsigned char *, size_t, HDB_Ext_Password *, size_t *); ASN1EXP int ASN1CALL encode_HDB_Ext_Password(unsigned char *, size_t, const HDB_Ext_Password *, size_t *); ASN1EXP size_t ASN1CALL length_HDB_Ext_Password(const HDB_Ext_Password *); ASN1EXP int ASN1CALL copy_HDB_Ext_Password (const HDB_Ext_Password *, HDB_Ext_Password *); ASN1EXP void ASN1CALL free_HDB_Ext_Password (HDB_Ext_Password *); /* HDB-Ext-Aliases ::= SEQUENCE { case-insensitive [0] BOOLEAN, aliases [1] SEQUENCE OF Principal, } */ typedef struct HDB_Ext_Aliases { int case_insensitive; struct HDB_Ext_Aliases_aliases { unsigned int len; Principal *val; } aliases; } HDB_Ext_Aliases; ASN1EXP int ASN1CALL decode_HDB_Ext_Aliases(const unsigned char *, size_t, HDB_Ext_Aliases *, size_t *); ASN1EXP int ASN1CALL encode_HDB_Ext_Aliases(unsigned char *, size_t, const HDB_Ext_Aliases *, size_t *); ASN1EXP size_t ASN1CALL length_HDB_Ext_Aliases(const HDB_Ext_Aliases *); ASN1EXP int ASN1CALL copy_HDB_Ext_Aliases (const HDB_Ext_Aliases *, HDB_Ext_Aliases *); ASN1EXP void ASN1CALL free_HDB_Ext_Aliases (HDB_Ext_Aliases *); /* Keys ::= SEQUENCE OF Key */ typedef struct Keys { unsigned int len; Key *val; } Keys; ASN1EXP int ASN1CALL add_Keys (Keys *, const Key *); ASN1EXP int ASN1CALL remove_Keys (Keys *, unsigned int); ASN1EXP int ASN1CALL decode_Keys(const unsigned char *, size_t, Keys *, size_t *); ASN1EXP int ASN1CALL encode_Keys(unsigned char *, size_t, const Keys *, size_t *); ASN1EXP size_t ASN1CALL length_Keys(const Keys *); ASN1EXP int ASN1CALL copy_Keys (const Keys *, Keys *); ASN1EXP void ASN1CALL free_Keys (Keys *); /* hdb_keyset ::= SEQUENCE { kvno [0] INTEGER (0..4294967295), keys [1] Keys, set-time [2] KerberosTime OPTIONAL, ..., } */ typedef struct hdb_keyset { unsigned int kvno; Keys keys; KerberosTime *set_time; } hdb_keyset; ASN1EXP int ASN1CALL decode_hdb_keyset(const unsigned char *, size_t, hdb_keyset *, size_t *); ASN1EXP int ASN1CALL encode_hdb_keyset(unsigned char *, size_t, const hdb_keyset *, size_t *); ASN1EXP size_t ASN1CALL length_hdb_keyset(const hdb_keyset *); ASN1EXP int ASN1CALL copy_hdb_keyset (const hdb_keyset *, hdb_keyset *); ASN1EXP void ASN1CALL free_hdb_keyset (hdb_keyset *); /* HDB-Ext-KeySet ::= SEQUENCE OF hdb_keyset */ typedef struct HDB_Ext_KeySet { unsigned int len; hdb_keyset *val; } HDB_Ext_KeySet; ASN1EXP int ASN1CALL add_HDB_Ext_KeySet (HDB_Ext_KeySet *, const hdb_keyset *); ASN1EXP int ASN1CALL remove_HDB_Ext_KeySet (HDB_Ext_KeySet *, unsigned int); ASN1EXP int ASN1CALL decode_HDB_Ext_KeySet(const unsigned char *, size_t, HDB_Ext_KeySet *, size_t *); ASN1EXP int ASN1CALL encode_HDB_Ext_KeySet(unsigned char *, size_t, const HDB_Ext_KeySet *, size_t *); ASN1EXP size_t ASN1CALL length_HDB_Ext_KeySet(const HDB_Ext_KeySet *); ASN1EXP int ASN1CALL copy_HDB_Ext_KeySet (const HDB_Ext_KeySet *, HDB_Ext_KeySet *); ASN1EXP void ASN1CALL free_HDB_Ext_KeySet (HDB_Ext_KeySet *); /* HDB-extension ::= SEQUENCE { mandatory [0] BOOLEAN, data [1] CHOICE { pkinit-acl [0] HDB-Ext-PKINIT-acl, pkinit-cert-hash [1] HDB-Ext-PKINIT-hash, allowed-to-delegate-to [2] HDB-Ext-Constrained-delegation-acl, lm-owf [4] HDB-Ext-Lan-Manager-OWF, password [5] HDB-Ext-Password, aliases [6] HDB-Ext-Aliases, last-pw-change [7] KerberosTime, pkinit-cert [8] HDB-Ext-PKINIT-cert, hist-keys [9] HDB-Ext-KeySet, hist-kvno-diff-clnt [10] INTEGER (0..4294967295), hist-kvno-diff-svc [11] INTEGER (0..4294967295), policy [12] UTF8String, principal-id [13] INTEGER (-9223372036854775808..9223372036854775807), ..., }, ..., } */ typedef struct HDB_extension { int mandatory; struct HDB_extension_data { enum HDB_extension_data_enum { choice_HDB_extension_data_asn1_ellipsis = 0, choice_HDB_extension_data_pkinit_acl, choice_HDB_extension_data_pkinit_cert_hash, choice_HDB_extension_data_allowed_to_delegate_to, choice_HDB_extension_data_lm_owf, choice_HDB_extension_data_password, choice_HDB_extension_data_aliases, choice_HDB_extension_data_last_pw_change, choice_HDB_extension_data_pkinit_cert, choice_HDB_extension_data_hist_keys, choice_HDB_extension_data_hist_kvno_diff_clnt, choice_HDB_extension_data_hist_kvno_diff_svc, choice_HDB_extension_data_policy, choice_HDB_extension_data_principal_id /* ... */ } element; union { HDB_Ext_PKINIT_acl pkinit_acl; HDB_Ext_PKINIT_hash pkinit_cert_hash; HDB_Ext_Constrained_delegation_acl allowed_to_delegate_to; HDB_Ext_Lan_Manager_OWF lm_owf; HDB_Ext_Password password; HDB_Ext_Aliases aliases; KerberosTime last_pw_change; HDB_Ext_PKINIT_cert pkinit_cert; HDB_Ext_KeySet hist_keys; unsigned int hist_kvno_diff_clnt; unsigned int hist_kvno_diff_svc; heim_utf8_string policy; int64_t principal_id; heim_octet_string asn1_ellipsis; } u; } data; } HDB_extension; ASN1EXP int ASN1CALL decode_HDB_extension(const unsigned char *, size_t, HDB_extension *, size_t *); ASN1EXP int ASN1CALL encode_HDB_extension(unsigned char *, size_t, const HDB_extension *, size_t *); ASN1EXP size_t ASN1CALL length_HDB_extension(const HDB_extension *); ASN1EXP int ASN1CALL copy_HDB_extension (const HDB_extension *, HDB_extension *); ASN1EXP void ASN1CALL free_HDB_extension (HDB_extension *); /* HDB-extensions ::= SEQUENCE OF HDB-extension */ typedef struct HDB_extensions { unsigned int len; HDB_extension *val; } HDB_extensions; ASN1EXP int ASN1CALL decode_HDB_extensions(const unsigned char *, size_t, HDB_extensions *, size_t *); ASN1EXP int ASN1CALL encode_HDB_extensions(unsigned char *, size_t, const HDB_extensions *, size_t *); ASN1EXP size_t ASN1CALL length_HDB_extensions(const HDB_extensions *); ASN1EXP int ASN1CALL copy_HDB_extensions (const HDB_extensions *, HDB_extensions *); ASN1EXP void ASN1CALL free_HDB_extensions (HDB_extensions *); /* hdb_entry ::= SEQUENCE { principal [0] Principal OPTIONAL, kvno [1] INTEGER (0..4294967295), keys [2] Keys, created-by [3] Event, modified-by [4] Event OPTIONAL, valid-start [5] KerberosTime OPTIONAL, valid-end [6] KerberosTime OPTIONAL, pw-end [7] KerberosTime OPTIONAL, max-life [8] INTEGER (0..4294967295) OPTIONAL, max-renew [9] INTEGER (0..4294967295) OPTIONAL, flags [10] HDBFlags, etypes [11] SEQUENCE OF INTEGER (0..4294967295) OPTIONAL, generation [12] GENERATION OPTIONAL, extensions [13] HDB-extensions OPTIONAL, } */ typedef struct hdb_entry { Principal *principal; unsigned int kvno; Keys keys; Event created_by; Event *modified_by; KerberosTime *valid_start; KerberosTime *valid_end; KerberosTime *pw_end; unsigned int *max_life; unsigned int *max_renew; HDBFlags flags; struct hdb_entry_etypes { unsigned int len; unsigned int *val; } *etypes; GENERATION *generation; HDB_extensions *extensions; } hdb_entry; ASN1EXP int ASN1CALL decode_hdb_entry(const unsigned char *, size_t, hdb_entry *, size_t *); ASN1EXP int ASN1CALL encode_hdb_entry(unsigned char *, size_t, const hdb_entry *, size_t *); ASN1EXP size_t ASN1CALL length_hdb_entry(const hdb_entry *); ASN1EXP int ASN1CALL copy_hdb_entry (const hdb_entry *, hdb_entry *); ASN1EXP void ASN1CALL free_hdb_entry (hdb_entry *); /* hdb_entry_alias ::= [APPLICATION 0] SEQUENCE { principal [0] Principal OPTIONAL, } */ typedef struct hdb_entry_alias { Principal *principal; } hdb_entry_alias; ASN1EXP int ASN1CALL decode_hdb_entry_alias(const unsigned char *, size_t, hdb_entry_alias *, size_t *); ASN1EXP int ASN1CALL encode_hdb_entry_alias(unsigned char *, size_t, const hdb_entry_alias *, size_t *); ASN1EXP size_t ASN1CALL length_hdb_entry_alias(const hdb_entry_alias *); ASN1EXP int ASN1CALL copy_hdb_entry_alias (const hdb_entry_alias *, hdb_entry_alias *); ASN1EXP void ASN1CALL free_hdb_entry_alias (hdb_entry_alias *); #endif /* __hdb_asn1_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/hdb_err.h000066400000000000000000000017611505521762700223770ustar00rootroot00000000000000/* Generated from hdb_err.et */ /* $Id$ */ #ifndef __hdb_err_h__ #define __hdb_err_h__ struct et_list; void initialize_hdb_error_table_r(struct et_list **); void initialize_hdb_error_table(void); #define init_hdb_err_tbl initialize_hdb_error_table typedef enum hdb_error_number{ HDB_ERR_UK_SERROR = 36150273, HDB_ERR_UK_RERROR = 36150274, HDB_ERR_NOENTRY = 36150275, HDB_ERR_DB_INUSE = 36150276, HDB_ERR_DB_CHANGED = 36150277, HDB_ERR_RECURSIVELOCK = 36150278, HDB_ERR_NOTLOCKED = 36150279, HDB_ERR_BADLOCKMODE = 36150280, HDB_ERR_CANT_LOCK_DB = 36150281, HDB_ERR_EXISTS = 36150282, HDB_ERR_BADVERSION = 36150283, HDB_ERR_NO_MKEY = 36150284, HDB_ERR_MANDATORY_OPTION = 36150285, HDB_ERR_NO_WRITE_SUPPORT = 36150286, HDB_ERR_NOT_FOUND_HERE = 36150287, HDB_ERR_MISUSE = 36150288, HDB_ERR_KVNO_NOT_FOUND = 36150289, HDB_ERR_WRONG_REALM = 36150290 } hdb_error_number; #define ERROR_TABLE_BASE_hdb 36150272 #define COM_ERR_BINDDOMAIN_hdb "heim_com_err36150272" #endif /* __hdb_err_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/heim-ipc.h000066400000000000000000000067051505521762700224700ustar00rootroot00000000000000/* * Copyright (c) 2009 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Portions Copyright (c) 2009 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include typedef struct heim_ipc *heim_ipc; typedef struct heim_sipc *heim_sipc; typedef struct heim_icred *heim_icred; typedef struct heim_isemaphore *heim_isemaphore; typedef struct heim_base_data heim_idata; typedef struct heim_sipc_call *heim_sipc_call; /* common */ void heim_ipc_free_cred(heim_icred); uid_t heim_ipc_cred_get_uid(heim_icred); gid_t heim_ipc_cred_get_gid(heim_icred); pid_t heim_ipc_cred_get_pid(heim_icred); pid_t heim_ipc_cred_get_session(heim_icred); void heim_ipc_main(void); heim_isemaphore heim_ipc_semaphore_create(long); long heim_ipc_semaphore_wait(heim_isemaphore, time_t); long heim_ipc_semaphore_signal(heim_isemaphore); void heim_ipc_semaphore_release(heim_isemaphore); #define HEIM_IPC_WAIT_FOREVER ((time_t)-1) void heim_ipc_free_data(heim_idata *); /* client */ int heim_ipc_init_context(const char *, heim_ipc *); void heim_ipc_free_context(heim_ipc); int heim_ipc_call(heim_ipc, const heim_idata *, heim_idata *, heim_icred *); int heim_ipc_async(heim_ipc, const heim_idata *, void *, void (*func)(void *, int, heim_idata *, heim_icred)); /* server */ #define HEIM_SIPC_TYPE_IPC 1 #define HEIM_SIPC_TYPE_UINT32 2 #define HEIM_SIPC_TYPE_HTTP 4 typedef void (*heim_ipc_complete)(heim_sipc_call, int, heim_idata *); typedef void (*heim_ipc_callback)(void *, const heim_idata *, const heim_icred, heim_ipc_complete, heim_sipc_call); int heim_sipc_launchd_mach_init(const char *, heim_ipc_callback, void *, heim_sipc *); int heim_sipc_stream_listener(int, int, heim_ipc_callback, void *, heim_sipc *); int heim_sipc_service_unix(const char *, heim_ipc_callback, void *, heim_sipc *); void heim_sipc_timeout(time_t); void heim_sipc_set_timeout_handler(void (*)(void)); void heim_sipc_free_context(heim_sipc); pykrb5-0.8.0/build_helpers/heimdal/include/heim_asn1.h000066400000000000000000000045201505521762700226320ustar00rootroot00000000000000/* * Copyright (c) 2003-2005 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef __HEIM_ANY_H__ #define __HEIM_ANY_H__ 1 int encode_heim_any(unsigned char *, size_t, const heim_any *, size_t *); int decode_heim_any(const unsigned char *, size_t, heim_any *, size_t *); void free_heim_any(heim_any *); size_t length_heim_any(const heim_any *); int copy_heim_any(const heim_any *, heim_any *); int encode_heim_any_set(unsigned char *, size_t, const heim_any_set *, size_t *); int decode_heim_any_set(const unsigned char *, size_t, heim_any_set *,size_t *); void free_heim_any_set(heim_any_set *); size_t length_heim_any_set(const heim_any_set *); int copy_heim_any_set(const heim_any_set *, heim_any_set *); int heim_any_cmp(const heim_any_set *, const heim_any_set *); #endif /* __HEIM_ANY_H__ */ pykrb5-0.8.0/build_helpers/heimdal/include/heim_err.h000066400000000000000000000030031505521762700225530ustar00rootroot00000000000000/* Generated from heim_err.et */ /* $Id$ */ #ifndef __heim_err_h__ #define __heim_err_h__ struct et_list; void initialize_heim_error_table_r(struct et_list **); void initialize_heim_error_table(void); #define init_heim_err_tbl initialize_heim_error_table typedef enum heim_error_number{ HEIM_ERR_LOG_PARSE = -1980176640, HEIM_ERR_V4_PRINC_NO_CONV = -1980176639, HEIM_ERR_SALTTYPE_NOSUPP = -1980176638, HEIM_ERR_NOHOST = -1980176637, HEIM_ERR_OPNOTSUPP = -1980176636, HEIM_ERR_EOF = -1980176635, HEIM_ERR_BAD_MKEY = -1980176634, HEIM_ERR_SERVICE_NOMATCH = -1980176633, HEIM_ERR_NOT_SEEKABLE = -1980176632, HEIM_ERR_TOO_BIG = -1980176631, HEIM_ERR_BAD_HDBENT_ENCODING = -1980176630, HEIM_ERR_RANDOM_OFFLINE = -1980176629, HEIM_PKINIT_NO_CERTIFICATE = -1980176576, HEIM_PKINIT_NO_PRIVATE_KEY = -1980176575, HEIM_PKINIT_NO_VALID_CA = -1980176574, HEIM_PKINIT_CERTIFICATE_INVALID = -1980176573, HEIM_PKINIT_PRIVATE_KEY_INVALID = -1980176572, HEIM_EAI_UNKNOWN = -1980176512, HEIM_EAI_ADDRFAMILY = -1980176511, HEIM_EAI_AGAIN = -1980176510, HEIM_EAI_BADFLAGS = -1980176509, HEIM_EAI_FAIL = -1980176508, HEIM_EAI_FAMILY = -1980176507, HEIM_EAI_MEMORY = -1980176506, HEIM_EAI_NODATA = -1980176505, HEIM_EAI_NONAME = -1980176504, HEIM_EAI_SERVICE = -1980176503, HEIM_EAI_SOCKTYPE = -1980176502, HEIM_EAI_SYSTEM = -1980176501, HEIM_NET_CONN_REFUSED = -1980176448 } heim_error_number; #define ERROR_TABLE_BASE_heim -1980176640 #define COM_ERR_BINDDOMAIN_heim "heim_com_err-1980176640" #endif /* __heim_err_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/heimbase.h000066400000000000000000000326061505521762700225510ustar00rootroot00000000000000/* * Copyright (c) 2010 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Portions Copyright (c) 2010 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef HEIM_BASE_H #define HEIM_BASE_H 1 #include #if !defined(WIN32) && !defined(HAVE_DISPATCH_DISPATCH_H) && defined(ENABLE_PTHREAD_SUPPORT) #include #endif #include #include #ifdef HAVE_STDBOOL_H #include #else #ifndef false #define false 0 #endif #ifndef true #define true 1 #endif #endif #define HEIM_BASE_API_VERSION 20130210 typedef void * heim_object_t; typedef unsigned int heim_tid_t; typedef heim_object_t heim_bool_t; typedef heim_object_t heim_null_t; #ifdef WIN32 typedef LONG heim_base_once_t; #define HEIM_BASE_ONCE_INIT 0 #elif defined(HAVE_DISPATCH_DISPATCH_H) typedef long heim_base_once_t; /* XXX arch dependant */ #define HEIM_BASE_ONCE_INIT 0 #elif defined(ENABLE_PTHREAD_SUPPORT) typedef pthread_once_t heim_base_once_t; #define HEIM_BASE_ONCE_INIT PTHREAD_ONCE_INIT #else typedef long heim_base_once_t; /* XXX arch dependant */ #define HEIM_BASE_ONCE_INIT 0 #endif #if !defined(__has_extension) #define __has_extension(x) 0 #endif #define HEIM_REQUIRE_GNUC(m,n,p) \ (((__GNUC__ * 10000) + (__GNUC_MINOR__ * 100) + __GNUC_PATCHLEVEL__) >= \ (((m) * 10000) + ((n) * 100) + (p))) #if __has_extension(__builtin_expect) || HEIM_REQUIRE_GNUC(3,0,0) #define heim_builtin_expect(_op,_res) __builtin_expect(_op,_res) #else #define heim_builtin_expect(_op,_res) (_op) #endif void * heim_retain(heim_object_t); void heim_release(heim_object_t); void heim_show(heim_object_t); typedef void (*heim_type_dealloc)(void *); void * heim_alloc(size_t size, const char *name, heim_type_dealloc dealloc); heim_tid_t heim_get_tid(heim_object_t object); int heim_cmp(heim_object_t a, heim_object_t b); unsigned long heim_get_hash(heim_object_t ptr); void heim_base_once_f(heim_base_once_t *, void *, void (*)(void *)); void heim_abort(const char *fmt, ...) HEIMDAL_NORETURN_ATTRIBUTE HEIMDAL_PRINTF_ATTRIBUTE((__printf__, 1, 2)); void heim_abortv(const char *fmt, va_list ap) HEIMDAL_NORETURN_ATTRIBUTE HEIMDAL_PRINTF_ATTRIBUTE((__printf__, 1, 0)); #define heim_assert(e,t) \ (heim_builtin_expect(!(e), 0) ? heim_abort(t ":" #e) : (void)0) /* * */ heim_null_t heim_null_create(void); heim_bool_t heim_bool_create(int); int heim_bool_val(heim_bool_t); /* * Array */ typedef struct heim_array_data *heim_array_t; heim_array_t heim_array_create(void); heim_tid_t heim_array_get_type_id(void); typedef void (*heim_array_iterator_f_t)(heim_object_t, void *, int *); typedef int (*heim_array_filter_f_t)(heim_object_t, void *); int heim_array_append_value(heim_array_t, heim_object_t); int heim_array_insert_value(heim_array_t, size_t idx, heim_object_t); void heim_array_iterate_f(heim_array_t, void *, heim_array_iterator_f_t); void heim_array_iterate_reverse_f(heim_array_t, void *, heim_array_iterator_f_t); #ifdef __BLOCKS__ void heim_array_iterate(heim_array_t, void (^)(heim_object_t, int *)); void heim_array_iterate_reverse(heim_array_t, void (^)(heim_object_t, int *)); #endif size_t heim_array_get_length(heim_array_t); heim_object_t heim_array_get_value(heim_array_t, size_t); heim_object_t heim_array_copy_value(heim_array_t, size_t); void heim_array_set_value(heim_array_t, size_t, heim_object_t); void heim_array_delete_value(heim_array_t, size_t); void heim_array_filter_f(heim_array_t, void *, heim_array_filter_f_t); #ifdef __BLOCKS__ void heim_array_filter(heim_array_t, int (^)(heim_object_t)); #endif /* * Dict */ typedef struct heim_dict_data *heim_dict_t; heim_dict_t heim_dict_create(size_t size); heim_tid_t heim_dict_get_type_id(void); typedef void (*heim_dict_iterator_f_t)(heim_object_t, heim_object_t, void *); int heim_dict_set_value(heim_dict_t, heim_object_t, heim_object_t); void heim_dict_iterate_f(heim_dict_t, void *, heim_dict_iterator_f_t); #ifdef __BLOCKS__ void heim_dict_iterate(heim_dict_t, void (^)(heim_object_t, heim_object_t)); #endif heim_object_t heim_dict_get_value(heim_dict_t, heim_object_t); heim_object_t heim_dict_copy_value(heim_dict_t, heim_object_t); void heim_dict_delete_key(heim_dict_t, heim_object_t); /* * String */ typedef struct heim_string_data *heim_string_t; typedef void (*heim_string_free_f_t)(void *); heim_string_t heim_string_create(const char *); heim_string_t heim_string_ref_create(const char *, heim_string_free_f_t); heim_string_t heim_string_create_with_bytes(const void *, size_t); heim_string_t heim_string_ref_create_with_bytes(const void *, size_t, heim_string_free_f_t); heim_string_t heim_string_create_with_format(const char *, ...); heim_tid_t heim_string_get_type_id(void); const char * heim_string_get_utf8(heim_string_t); #define HSTR(_str) (__heim_string_constant("" _str "")) heim_string_t __heim_string_constant(const char *); /* * Errors */ typedef struct heim_error * heim_error_t; heim_error_t heim_error_create_enomem(void); heim_error_t heim_error_create(int, const char *, ...) HEIMDAL_PRINTF_ATTRIBUTE((__printf__, 2, 3)); void heim_error_create_opt(heim_error_t *error, int error_code, const char *fmt, ...) HEIMDAL_PRINTF_ATTRIBUTE((__printf__, 3, 4)); heim_error_t heim_error_createv(int, const char *, va_list) HEIMDAL_PRINTF_ATTRIBUTE((__printf__, 2, 0)); heim_string_t heim_error_copy_string(heim_error_t); int heim_error_get_code(heim_error_t); heim_error_t heim_error_append(heim_error_t, heim_error_t); /* * Path */ heim_object_t heim_path_get(heim_object_t ptr, heim_error_t *error, ...); heim_object_t heim_path_copy(heim_object_t ptr, heim_error_t *error, ...); heim_object_t heim_path_vget(heim_object_t ptr, heim_error_t *error, va_list ap); heim_object_t heim_path_vcopy(heim_object_t ptr, heim_error_t *error, va_list ap); int heim_path_vcreate(heim_object_t ptr, size_t size, heim_object_t leaf, heim_error_t *error, va_list ap); int heim_path_create(heim_object_t ptr, size_t size, heim_object_t leaf, heim_error_t *error, ...); void heim_path_vdelete(heim_object_t ptr, heim_error_t *error, va_list ap); void heim_path_delete(heim_object_t ptr, heim_error_t *error, ...); /* * Data (octet strings) */ #ifndef __HEIM_BASE_DATA__ #define __HEIM_BASE_DATA__ struct heim_base_data { size_t length; void *data; }; typedef struct heim_base_data heim_octet_string; #endif typedef struct heim_base_data * heim_data_t; typedef void (*heim_data_free_f_t)(void *); heim_data_t heim_data_create(const void *, size_t); heim_data_t heim_data_ref_create(const void *, size_t, heim_data_free_f_t); heim_tid_t heim_data_get_type_id(void); const heim_octet_string * heim_data_get_data(heim_data_t); const void * heim_data_get_ptr(heim_data_t); size_t heim_data_get_length(heim_data_t); /* * DB */ typedef struct heim_db_data *heim_db_t; typedef void (*heim_db_iterator_f_t)(heim_data_t, heim_data_t, void *); typedef int (*heim_db_plug_open_f_t)(void *, const char *, const char *, heim_dict_t, void **, heim_error_t *); typedef int (*heim_db_plug_clone_f_t)(void *, void **, heim_error_t *); typedef int (*heim_db_plug_close_f_t)(void *, heim_error_t *); typedef int (*heim_db_plug_lock_f_t)(void *, int, heim_error_t *); typedef int (*heim_db_plug_unlock_f_t)(void *, heim_error_t *); typedef int (*heim_db_plug_sync_f_t)(void *, heim_error_t *); typedef int (*heim_db_plug_begin_f_t)(void *, int, heim_error_t *); typedef int (*heim_db_plug_commit_f_t)(void *, heim_error_t *); typedef int (*heim_db_plug_rollback_f_t)(void *, heim_error_t *); typedef heim_data_t (*heim_db_plug_copy_value_f_t)(void *, heim_string_t, heim_data_t, heim_error_t *); typedef int (*heim_db_plug_set_value_f_t)(void *, heim_string_t, heim_data_t, heim_data_t, heim_error_t *); typedef int (*heim_db_plug_del_key_f_t)(void *, heim_string_t, heim_data_t, heim_error_t *); typedef void (*heim_db_plug_iter_f_t)(void *, heim_string_t, void *, heim_db_iterator_f_t, heim_error_t *); struct heim_db_type { int version; heim_db_plug_open_f_t openf; heim_db_plug_clone_f_t clonef; heim_db_plug_close_f_t closef; heim_db_plug_lock_f_t lockf; heim_db_plug_unlock_f_t unlockf; heim_db_plug_sync_f_t syncf; heim_db_plug_begin_f_t beginf; heim_db_plug_commit_f_t commitf; heim_db_plug_rollback_f_t rollbackf; heim_db_plug_copy_value_f_t copyf; heim_db_plug_set_value_f_t setf; heim_db_plug_del_key_f_t delf; heim_db_plug_iter_f_t iterf; }; extern struct heim_db_type heim_sorted_text_file_dbtype; #define HEIM_DB_TYPE_VERSION_01 1 int heim_db_register(const char *dbtype, void *data, struct heim_db_type *plugin); heim_db_t heim_db_create(const char *dbtype, const char *dbname, heim_dict_t options, heim_error_t *error); heim_db_t heim_db_clone(heim_db_t, heim_error_t *); int heim_db_begin(heim_db_t, int, heim_error_t *); int heim_db_commit(heim_db_t, heim_error_t *); int heim_db_rollback(heim_db_t, heim_error_t *); heim_tid_t heim_db_get_type_id(void); int heim_db_set_value(heim_db_t, heim_string_t, heim_data_t, heim_data_t, heim_error_t *); heim_data_t heim_db_copy_value(heim_db_t, heim_string_t, heim_data_t, heim_error_t *); int heim_db_delete_key(heim_db_t, heim_string_t, heim_data_t, heim_error_t *); void heim_db_iterate_f(heim_db_t, heim_string_t, void *, heim_db_iterator_f_t, heim_error_t *); #ifdef __BLOCKS__ void heim_db_iterate(heim_db_t, heim_string_t, void (^)(heim_data_t, heim_data_t), heim_error_t *); #endif /* * Number */ typedef struct heim_number_data *heim_number_t; heim_number_t heim_number_create(int); heim_tid_t heim_number_get_type_id(void); int heim_number_get_int(heim_number_t); /* * */ typedef struct heim_auto_release * heim_auto_release_t; heim_auto_release_t heim_auto_release_create(void); void heim_auto_release_drain(heim_auto_release_t); heim_object_t heim_auto_release(heim_object_t); /* * JSON */ typedef enum heim_json_flags { HEIM_JSON_F_NO_C_NULL = 1, HEIM_JSON_F_STRICT_STRINGS = 2, HEIM_JSON_F_NO_DATA = 4, HEIM_JSON_F_NO_DATA_DICT = 8, HEIM_JSON_F_STRICT_DICT = 16, HEIM_JSON_F_STRICT = 31, HEIM_JSON_F_CNULL2JSNULL = 32, HEIM_JSON_F_TRY_DECODE_DATA = 64, HEIM_JSON_F_ONE_LINE = 128 } heim_json_flags_t; heim_object_t heim_json_create(const char *, size_t, heim_json_flags_t, heim_error_t *); heim_object_t heim_json_create_with_bytes(const void *, size_t, size_t, heim_json_flags_t, heim_error_t *); heim_string_t heim_json_copy_serialize(heim_object_t, heim_json_flags_t, heim_error_t *); /* * Debug */ heim_string_t heim_description(heim_object_t ptr); /* * Binary search. * * Note: these are private until integrated into the heimbase object system. */ typedef struct bsearch_file_handle *bsearch_file_handle; int _bsearch_text(const char *buf, size_t buf_sz, const char *key, char **value, size_t *location, size_t *loops); int _bsearch_file_open(const char *fname, size_t max_sz, size_t page_sz, bsearch_file_handle *bfh, size_t *reads); int _bsearch_file(bsearch_file_handle bfh, const char *key, char **value, size_t *location, size_t *loops, size_t *reads); void _bsearch_file_info(bsearch_file_handle bfh, size_t *page_sz, size_t *max_sz, int *blockwise); void _bsearch_file_close(bsearch_file_handle *bfh); /* * Thread-specific keys */ int heim_w32_key_create(unsigned long *, void (*)(void *)); int heim_w32_delete_key(unsigned long); int heim_w32_setspecific(unsigned long, void *); void *heim_w32_getspecific(unsigned long); void heim_w32_service_thread_detach(void *); #endif /* HEIM_BASE_H */ pykrb5-0.8.0/build_helpers/heimdal/include/heimntlm-protos.h000066400000000000000000000252221505521762700241310ustar00rootroot00000000000000/* This is a generated file */ #ifndef __heimntlm_protos_h__ #define __heimntlm_protos_h__ #ifndef DOXY #include #ifdef __cplusplus extern "C" { #endif /** * Generates an NTLMv1 session random with assosited session master key. * * @param key the ntlm v1 key * @param len length of key * @param session generated session nonce, should be freed with heim_ntlm_free_buf(). * @param master calculated session master key, should be freed with heim_ntlm_free_buf(). * * @return In case of success 0 is return, an errors, a errno in what * went wrong. * * @ingroup ntlm_core */ int heim_ntlm_build_ntlm1_master ( void */*key*/, size_t /*len*/, struct ntlm_buf */*session*/, struct ntlm_buf */*master*/); /** * Generates an NTLMv2 session random with associated session master key. * * @param key the NTLMv2 key * @param len length of key * @param blob the NTLMv2 "blob" * @param session generated session nonce, should be freed with heim_ntlm_free_buf(). * @param master calculated session master key, should be freed with heim_ntlm_free_buf(). * * @return In case of success 0 is return, an errors, a errno in what * went wrong. * * @ingroup ntlm_core */ int heim_ntlm_build_ntlm2_master ( void */*key*/, size_t /*len*/, struct ntlm_buf */*blob*/, struct ntlm_buf */*session*/, struct ntlm_buf */*master*/); /** * Calculate LMv2 response * * @param key the ntlm key * @param len length of key * @param username name of the user, as sent in the message, assumed to be in UTF8. * @param target the name of the target, assumed to be in UTF8. * @param serverchallenge challenge as sent by the server in the type2 message. * @param ntlmv2 calculated session key * @param answer ntlm response answer, should be freed with heim_ntlm_free_buf(). * * @return In case of success 0 is return, an errors, a errno in what * went wrong. * * @ingroup ntlm_core */ int heim_ntlm_calculate_lm2 ( const void */*key*/, size_t /*len*/, const char */*username*/, const char */*target*/, const unsigned char serverchallenge[8], unsigned char ntlmv2[16], struct ntlm_buf */*answer*/); /** * Calculate NTLMv1 response hash * * @param key the ntlm v1 key * @param len length of key * @param challenge sent by the server * @param answer calculated answer, should be freed with heim_ntlm_free_buf(). * * @return In case of success 0 is return, an errors, a errno in what * went wrong. * * @ingroup ntlm_core */ int heim_ntlm_calculate_ntlm1 ( void */*key*/, size_t /*len*/, unsigned char challenge[8], struct ntlm_buf */*answer*/); /** * Calculate NTLMv2 response * * @param key the ntlm key * @param len length of key * @param username name of the user, as sent in the message, assumed to be in UTF8. * @param target the name of the target, assumed to be in UTF8. * @param serverchallenge challenge as sent by the server in the type2 message. * @param infotarget infotarget as sent by the server in the type2 message. * @param ntlmv2 calculated session key * @param answer ntlm response answer, should be freed with heim_ntlm_free_buf(). * * @return In case of success 0 is return, an errors, a errno in what * went wrong. * * @ingroup ntlm_core */ int heim_ntlm_calculate_ntlm2 ( const void */*key*/, size_t /*len*/, const char */*username*/, const char */*target*/, const unsigned char serverchallenge[8], const struct ntlm_buf */*infotarget*/, unsigned char ntlmv2[16], struct ntlm_buf */*answer*/); /** * Third check with empty domain. */ int heim_ntlm_calculate_ntlm2_sess ( const unsigned char clnt_nonce[8], const unsigned char svr_chal[8], const unsigned char ntlm_hash[16], struct ntlm_buf */*lm*/, struct ntlm_buf */*ntlm*/); int heim_ntlm_calculate_ntlm2_sess_hash ( const unsigned char clnt_nonce[8], const unsigned char svr_chal[8], unsigned char verifier[8]); /** * Decodes an NTLM targetinfo message * * @param data input data buffer with the encode NTLM targetinfo message * @param ucs2 if the strings should be encoded with ucs2 (selected by flag in message). * @param ti the decoded target info, should be freed with heim_ntlm_free_targetinfo(). * * @return In case of success 0 is return, an errors, a errno in what * went wrong. * * @ingroup ntlm_core */ int heim_ntlm_decode_targetinfo ( const struct ntlm_buf */*data*/, int /*ucs2*/, struct ntlm_targetinfo */*ti*/); int heim_ntlm_decode_type1 ( const struct ntlm_buf */*buf*/, struct ntlm_type1 */*data*/); int heim_ntlm_decode_type2 ( const struct ntlm_buf */*buf*/, struct ntlm_type2 */*type2*/); int heim_ntlm_decode_type3 ( const struct ntlm_buf */*buf*/, int /*ucs2*/, struct ntlm_type3 */*type3*/); void heim_ntlm_derive_ntlm2_sess ( const unsigned char sessionkey[16], const unsigned char */*clnt_nonce*/, size_t /*clnt_nonce_length*/, const unsigned char svr_chal[8], unsigned char derivedkey[16]); /** * Encodes a ntlm_targetinfo message. * * @param ti the ntlm_targetinfo message to encode. * @param ucs2 ignored * @param data is the return buffer with the encoded message, should be * freed with heim_ntlm_free_buf(). * * @return In case of success 0 is return, an errors, a errno in what * went wrong. * * @ingroup ntlm_core */ int heim_ntlm_encode_targetinfo ( const struct ntlm_targetinfo */*ti*/, int /*ucs2*/, struct ntlm_buf */*data*/); /** * Encodes an ntlm_type1 message. * * @param type1 the ntlm_type1 message to encode. * @param data is the return buffer with the encoded message, should be * freed with heim_ntlm_free_buf(). * * @return In case of success 0 is return, an errors, a errno in what * went wrong. * * @ingroup ntlm_core */ int heim_ntlm_encode_type1 ( const struct ntlm_type1 */*type1*/, struct ntlm_buf */*data*/); /** * Encodes an ntlm_type2 message. * * @param type2 the ntlm_type2 message to encode. * @param data is the return buffer with the encoded message, should be * freed with heim_ntlm_free_buf(). * * @return In case of success 0 is return, an errors, a errno in what * went wrong. * * @ingroup ntlm_core */ int heim_ntlm_encode_type2 ( const struct ntlm_type2 */*type2*/, struct ntlm_buf */*data*/); /** * Encodes an ntlm_type3 message. * * @param type3 the ntlm_type3 message to encode. * @param data is the return buffer with the encoded message, should be * @param[out] mic_offset offset of message integrity code * freed with heim_ntlm_free_buf(). * * @return In case of success 0 is return, an errors, a errno in what * went wrong. * * @ingroup ntlm_core */ int heim_ntlm_encode_type3 ( const struct ntlm_type3 */*type3*/, struct ntlm_buf */*data*/, size_t */*mic_offset*/); /** * heim_ntlm_free_buf frees the ntlm buffer * * @param p buffer to be freed * * @ingroup ntlm_core */ void heim_ntlm_free_buf (struct ntlm_buf */*p*/); /** * Frees the ntlm_targetinfo message * * @param ti targetinfo to be freed * * @ingroup ntlm_core */ void heim_ntlm_free_targetinfo (struct ntlm_targetinfo */*ti*/); /** * Frees the ntlm_type1 message * * @param data message to be freed * * @ingroup ntlm_core */ void heim_ntlm_free_type1 (struct ntlm_type1 */*data*/); /** * Frees the ntlm_type2 message * * @param data message to be freed * * @ingroup ntlm_core */ void heim_ntlm_free_type2 (struct ntlm_type2 */*data*/); /** * Frees the ntlm_type3 message * * @param data message to be freed * * @ingroup ntlm_core */ void heim_ntlm_free_type3 (struct ntlm_type3 */*data*/); /** * Given a key and encrypted session, unwrap the session key * * @param baseKey the sessionBaseKey * @param encryptedSession encrypted session, type3.session field. * @param session generated session nonce, should be freed with heim_ntlm_free_buf(). * * @return In case of success 0 is return, an errors, a errno in what * went wrong. * * @ingroup ntlm_core */ int heim_ntlm_keyex_unwrap ( struct ntlm_buf */*baseKey*/, struct ntlm_buf */*encryptedSession*/, struct ntlm_buf */*session*/); int heim_ntlm_keyex_wrap ( struct ntlm_buf */*base_session*/, struct ntlm_buf */*session*/, struct ntlm_buf */*encryptedSession*/); /** * Calculate the NTLM key, the password is assumed to be in UTF8. * * @param password password to calcute the key for. * @param key calcuted key, should be freed with heim_ntlm_free_buf(). * * @return In case of success 0 is return, an errors, a errno in what * went wrong. * * @ingroup ntlm_core */ int heim_ntlm_nt_key ( const char */*password*/, struct ntlm_buf */*key*/); /** * Generates an NTLMv2 session key. * * @param key the ntlm key * @param len length of key * @param username name of the user, as sent in the message, assumed to be in UTF8. * @param target the name of the target, assumed to be in UTF8. * @param upper_case_target upper case the target, should not be used only for legacy systems * @param ntlmv2 the ntlmv2 session key * * @return 0 on success, or an error code on failure. * * @ingroup ntlm_core */ int heim_ntlm_ntlmv2_key ( const void */*key*/, size_t /*len*/, const char */*username*/, const char */*target*/, int /*upper_case_target*/, unsigned char ntlmv2[16]); time_t heim_ntlm_ts2unixtime (uint64_t /*t*/); uint64_t heim_ntlm_unix2ts_time (time_t /*unix_time*/); /** @defgroup ntlm_core Heimdal NTLM library * * The NTLM core functions implement the string2key generation * function, message encode and decode function, and the hash function * functions. */ size_t heim_ntlm_unparse_flags ( uint32_t /*flags*/, char */*s*/, size_t /*len*/); int heim_ntlm_v1_base_session ( void */*key*/, size_t /*len*/, struct ntlm_buf */*session*/); int heim_ntlm_v2_base_session ( void */*key*/, size_t /*len*/, struct ntlm_buf */*ntlmResponse*/, struct ntlm_buf */*session*/); /** * Verify NTLMv2 response. * * @param key the ntlm key * @param len length of key * @param username name of the user, as sent in the message, assumed to be in UTF8. * @param target the name of the target, assumed to be in UTF8. * @param now the time now (0 if the library should pick it up itself) * @param serverchallenge challenge as sent by the server in the type2 message. * @param answer ntlm response answer, should be freed with heim_ntlm_free_buf(). * @param infotarget infotarget as sent by the server in the type2 message. * @param ntlmv2 calculated session key * * @return In case of success 0 is return, an errors, a errno in what * went wrong. * * @ingroup ntlm_core */ int heim_ntlm_verify_ntlm2 ( const void */*key*/, size_t /*len*/, const char */*username*/, const char */*target*/, time_t /*now*/, const unsigned char serverchallenge[8], const struct ntlm_buf */*answer*/, struct ntlm_buf */*infotarget*/, unsigned char ntlmv2[16]); #ifdef __cplusplus } #endif #endif /* DOXY */ #endif /* __heimntlm_protos_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/heimntlm.h000066400000000000000000000121551505521762700226060ustar00rootroot00000000000000/* * Copyright (c) 2006 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef HEIM_NTLM_H #define HEIM_NTLM_H /** * Buffer for storing data in the NTLM library. When filled in by the * library it should be freed with heim_ntlm_free_buf(). */ struct ntlm_buf { size_t length; /**< length buffer data */ void *data; /**< pointer to the data itself */ }; #define NTLM_NEG_UNICODE 0x00000001 #define NTLM_NEG_OEM 0x00000002 #define NTLM_NEG_TARGET 0x00000004 #define NTLM_MBZ9 0x00000008 #define NTLM_NEG_SIGN 0x00000010 #define NTLM_NEG_SEAL 0x00000020 #define NTLM_NEG_DATAGRAM 0x00000040 #define NTLM_NEG_LM_KEY 0x00000080 #define NTLM_NEG_NTLM 0x00000200 #define NTLM_NEG_ANONYMOUS 0x00000800 #define NTLM_MBZ8 0x00000100 #define NTLM_NEG_NTLM 0x00000200 #define NTLM_NEG_NT_ONLY 0x00000400 #define NTLM_MBZ7 0x00000800 /* anon ? */ #define NTLM_OEM_SUPPLIED_DOMAIN 0x00001000 #define NTLM_OEM_SUPPLIED_WORKSTATION 0x00002000 #define NTLM_MBZ6 0x00004000 /* local call ? */ #define NTLM_NEG_ALWAYS_SIGN 0x00008000 #define NTLM_TARGET_DOMAIN 0x00010000 #define NTLM_TARGET_SERVER 0x00020000 #define NTLM_TARGET_SHARE 0x00040000 /* mbz */ #define NTLM_NEG_NTLM2_SESSION 0x00080000 /* EXTENDED_SESSIONSECURITY */ #define NTLM_NEG_NTLM2 0x00080000 #define NTLM_NEG_IDENTIFY 0x00100000 #define NTLM_MBZ5 0x00200000 #define NTLM_NON_NT_SESSION_KEY 0x00400000 #define NTLM_NEG_TARGET_INFO 0x00800000 #define NTLM_MBZ4 0x01000000 #define NTLM_NEG_VERSION 0x02000000 #define NTLM_MBZ3 0x04000000 #define NTLM_MBZ2 0x08000000 #define NTLM_MBZ1 0x10000000 #define NTLM_ENC_128 0x20000000 #define NTLM_NEG_KEYEX 0x40000000 #define NTLM_ENC_56 0x80000000 /** * Struct for the NTLM target info, the strings is assumed to be in * UTF8. When filled in by the library it should be freed with * heim_ntlm_free_targetinfo(). */ /* avflags */ #define NTLM_TI_AV_FLAG_GUEST 0x00000001 #define NTLM_TI_AV_FLAG_MIC 0x00000002 struct ntlm_targetinfo { char *servername; /**< */ char *domainname; /**< */ char *dnsdomainname; /**< */ char *dnsservername; /**< */ char *dnstreename; /**< */ uint32_t avflags; /**< */ char *targetname; struct ntlm_buf channel_bindings; uint64_t timestamp; }; /** * Struct for the NTLM type1 message info, the strings is assumed to * be in UTF8. When filled in by the library it should be freed with * heim_ntlm_free_type1(). */ struct ntlm_type1 { uint32_t flags; /**< */ char *domain; /**< */ char *hostname; /**< */ uint32_t os[2]; /**< */ }; /** * Struct for the NTLM type2 message info, the strings is assumed to * be in UTF8. When filled in by the library it should be freed with * heim_ntlm_free_type2(). */ struct ntlm_type2 { uint32_t flags; /**< */ char *targetname; /**< */ struct ntlm_buf targetinfo; /**< */ unsigned char challenge[8]; /**< */ uint32_t context[2]; /**< */ uint32_t os[2]; /**< */ }; /** * Struct for the NTLM type3 message info, the strings is assumed to * be in UTF8. When filled in by the library it should be freed with * heim_ntlm_free_type3(). */ struct ntlm_type3 { uint32_t flags; /**< */ char *username; /**< */ char *targetname; /**< */ struct ntlm_buf lm; /**< */ struct ntlm_buf ntlm; /**< */ struct ntlm_buf sessionkey; /**< */ char *ws; /**< */ uint32_t os[2]; /**< */ size_t mic_offset; uint8_t mic[16]; }; extern time_t heim_ntlm_time_skew; #include #include #endif /* NTLM_NTLM_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hex.h000066400000000000000000000041211505521762700215470ustar00rootroot00000000000000/* * Copyright (c) 2005 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef _rk_HEX_H_ #define _rk_HEX_H_ 1 #ifndef ROKEN_LIB_FUNCTION #ifdef _WIN32 #define ROKEN_LIB_FUNCTION #define ROKEN_LIB_CALL __cdecl #else #define ROKEN_LIB_FUNCTION #define ROKEN_LIB_CALL #endif #endif #define hex_encode rk_hex_encode #define hex_decode rk_hex_decode ROKEN_LIB_FUNCTION ssize_t ROKEN_LIB_CALL hex_encode(const void *, size_t, char **); ROKEN_LIB_FUNCTION ssize_t ROKEN_LIB_CALL hex_decode(const char *, void *, size_t); #endif /* _rk_HEX_H_ */ pykrb5-0.8.0/build_helpers/heimdal/include/hx509-protos.h000066400000000000000000002145501505521762700231750ustar00rootroot00000000000000/* This is a generated file */ #ifndef __hx509_protos_h__ #define __hx509_protos_h__ #ifndef DOXY #include #ifdef __cplusplus extern "C" { #endif #ifndef HX509_LIB #ifndef HX509_LIB_FUNCTION #if defined(_WIN32) #define HX509_LIB_FUNCTION __declspec(dllimport) #define HX509_LIB_CALL __stdcall #define HX509_LIB_VARIABLE __declspec(dllimport) #else #define HX509_LIB_FUNCTION #define HX509_LIB_CALL #define HX509_LIB_VARIABLE #endif #endif #endif /** * Print a bitstring using a hx509_vprint_func function. To print to * stdout use hx509_print_stdout(). * * @param b bit string to print. * @param func hx509_vprint_func to print with. * @param ctx context variable to hx509_vprint_func function. * * @ingroup hx509_print */ void hx509_bitstring_print ( const heim_bit_string */*b*/, hx509_vprint_func /*func*/, void */*ctx*/); /** * Sign a to-be-signed certificate object with a issuer certificate. * * The caller needs to at least have called the following functions on the * to-be-signed certificate object: * - hx509_ca_tbs_init() * - hx509_ca_tbs_set_subject() * - hx509_ca_tbs_set_spki() * * When done the to-be-signed certificate object should be freed with * hx509_ca_tbs_free(). * * When creating self-signed certificate use hx509_ca_sign_self() instead. * * @param context A hx509 context. * @param tbs object to be signed. * @param signer the CA certificate object to sign with (need private key). * @param certificate return cerificate, free with hx509_cert_free(). * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_sign ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, hx509_cert /*signer*/, hx509_cert */*certificate*/); /** * Work just like hx509_ca_sign() but signs it-self. * * @param context A hx509 context. * @param tbs object to be signed. * @param signer private key to sign with. * @param certificate return cerificate, free with hx509_cert_free(). * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_sign_self ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, hx509_private_key /*signer*/, hx509_cert */*certificate*/); /** * Add CRL distribution point URI to the to-be-signed certificate * object. * * @param context A hx509 context. * @param tbs object to be signed. * @param uri uri to the CRL. * @param issuername name of the issuer. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_add_crl_dp_uri ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, const char */*uri*/, hx509_name /*issuername*/); /** * An an extended key usage to the to-be-signed certificate object. * Duplicates will detected and not added. * * @param context A hx509 context. * @param tbs object to be signed. * @param oid extended key usage to add. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_add_eku ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, const heim_oid */*oid*/); /** * Add a Subject Alternative Name hostname to to-be-signed certificate * object. A domain match starts with ., an exact match does not. * * Example of a an domain match: .domain.se matches the hostname * host.domain.se. * * @param context A hx509 context. * @param tbs object to be signed. * @param dnsname a hostame. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_add_san_hostname ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, const char */*dnsname*/); /** * Add a Jabber/XMPP jid Subject Alternative Name to the to-be-signed * certificate object. The jid is an UTF8 string. * * @param context A hx509 context. * @param tbs object to be signed. * @param jid string of an a jabber id in UTF8. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_add_san_jid ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, const char */*jid*/); /** * Add Microsoft UPN Subject Alternative Name to the to-be-signed * certificate object. The principal string is a UTF8 string. * * @param context A hx509 context. * @param tbs object to be signed. * @param principal Microsoft UPN string. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_add_san_ms_upn ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, const char */*principal*/); /** * Add Subject Alternative Name otherName to the to-be-signed * certificate object. * * @param context A hx509 context. * @param tbs object to be signed. * @param oid the oid of the OtherName. * @param os data in the other name. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_add_san_otherName ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, const heim_oid */*oid*/, const heim_octet_string */*os*/); /** * Add Kerberos Subject Alternative Name to the to-be-signed * certificate object. The principal string is a UTF8 string. * * @param context A hx509 context. * @param tbs object to be signed. * @param principal Kerberos principal to add to the certificate. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_add_san_pkinit ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, const char */*principal*/); /** * Add a Subject Alternative Name rfc822 (email address) to * to-be-signed certificate object. * * @param context A hx509 context. * @param tbs object to be signed. * @param rfc822Name a string to a email address. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_add_san_rfc822name ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, const char */*rfc822Name*/); /** * Free an To Be Signed object. * * @param tbs object to free. * * @ingroup hx509_ca */ void hx509_ca_tbs_free (hx509_ca_tbs */*tbs*/); /** * Allocate an to-be-signed certificate object that will be converted * into an certificate. * * @param context A hx509 context. * @param tbs returned to-be-signed certicate object, free with * hx509_ca_tbs_free(). * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_init ( hx509_context /*context*/, hx509_ca_tbs */*tbs*/); /** * Make the to-be-signed certificate object a CA certificate. If the * pathLenConstraint is negative path length constraint is used. * * @param context A hx509 context. * @param tbs object to be signed. * @param pathLenConstraint path length constraint, negative, no * constraint. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_set_ca ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, int /*pathLenConstraint*/); /** * Make the to-be-signed certificate object a windows domain controller certificate. * * @param context A hx509 context. * @param tbs object to be signed. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_set_domaincontroller ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/); /** * Set the absolute time when the certificate is valid to. * * @param context A hx509 context. * @param tbs object to be signed. * @param t time when the certificate will expire * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_set_notAfter ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, time_t /*t*/); /** * Set the relative time when the certificiate is going to expire. * * @param context A hx509 context. * @param tbs object to be signed. * @param delta seconds to the certificate is going to expire. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_set_notAfter_lifetime ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, time_t /*delta*/); /** * Set the absolute time when the certificate is valid from. If not * set the current time will be used. * * @param context A hx509 context. * @param tbs object to be signed. * @param t time the certificated will start to be valid * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_set_notBefore ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, time_t /*t*/); /** * Make the to-be-signed certificate object a proxy certificate. If the * pathLenConstraint is negative path length constraint is used. * * @param context A hx509 context. * @param tbs object to be signed. * @param pathLenConstraint path length constraint, negative, no * constraint. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_set_proxy ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, int /*pathLenConstraint*/); /** * Set the serial number to use for to-be-signed certificate object. * * @param context A hx509 context. * @param tbs object to be signed. * @param serialNumber serial number to use for the to-be-signed * certificate object. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_set_serialnumber ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, const heim_integer */*serialNumber*/); /** * Set signature algorithm on the to be signed certificate * * @param context A hx509 context. * @param tbs object to be signed. * @param sigalg signature algorithm to use * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_set_signature_algorithm ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, const AlgorithmIdentifier */*sigalg*/); /** * Set the subject public key info (SPKI) in the to-be-signed certificate * object. SPKI is the public key and key related parameters in the * certificate. * * @param context A hx509 context. * @param tbs object to be signed. * @param spki subject public key info to use for the to-be-signed certificate object. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_set_spki ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, const SubjectPublicKeyInfo */*spki*/); /** * Set the subject name of a to-be-signed certificate object. * * @param context A hx509 context. * @param tbs object to be signed. * @param subject the name to set a subject. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_set_subject ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, hx509_name /*subject*/); /** * Initialize the to-be-signed certificate object from a template certifiate. * * @param context A hx509 context. * @param tbs object to be signed. * @param flags bit field selecting what to copy from the template * certifiate. * @param cert template certificate. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_set_template ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, int /*flags*/, hx509_cert /*cert*/); /** * Set the issuerUniqueID and subjectUniqueID * * These are only supposed to be used considered with version 2 * certificates, replaced by the two extensions SubjectKeyIdentifier * and IssuerKeyIdentifier. This function is to allow application * using legacy protocol to issue them. * * @param context A hx509 context. * @param tbs object to be signed. * @param issuerUniqueID to be set * @param subjectUniqueID to be set * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_set_unique ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, const heim_bit_string */*subjectUniqueID*/, const heim_bit_string */*issuerUniqueID*/); /** * Expand the the subject name in the to-be-signed certificate object * using hx509_name_expand(). * * @param context A hx509 context. * @param tbs object to be signed. * @param env environment variable to expand variables in the subject * name, see hx509_env_init(). * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_ca */ int hx509_ca_tbs_subject_expand ( hx509_context /*context*/, hx509_ca_tbs /*tbs*/, hx509_env /*env*/); /** * Make of template units, use to build flags argument to * hx509_ca_tbs_set_template() with parse_units(). * * @return an units structure. * * @ingroup hx509_ca */ const struct units * hx509_ca_tbs_template_units (void); /** * Encodes the hx509 certificate as a DER encode binary. * * @param context A hx509 context. * @param c the certificate to encode. * @param os the encode certificate, set to NULL, 0 on case of * error. Free the os->data with hx509_xfree(). * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_cert */ int hx509_cert_binary ( hx509_context /*context*/, hx509_cert /*c*/, heim_octet_string */*os*/); /** * Check the extended key usage on the hx509 certificate. * * @param context A hx509 context. * @param cert A hx509 context. * @param eku the EKU to check for * @param allow_any_eku if the any EKU is set, allow that to be a * substitute. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_cert */ int hx509_cert_check_eku ( hx509_context /*context*/, hx509_cert /*cert*/, const heim_oid */*eku*/, int /*allow_any_eku*/); /** * Compare to hx509 certificate object, useful for sorting. * * @param p a hx509 certificate object. * @param q a hx509 certificate object. * * @return 0 the objects are the same, returns > 0 is p is "larger" * then q, < 0 if p is "smaller" then q. * * @ingroup hx509_cert */ int hx509_cert_cmp ( hx509_cert /*p*/, hx509_cert /*q*/); /** * Return a list of subjectAltNames specified by oid in the * certificate. On error the * * The returned list of octet string should be freed with * hx509_free_octet_string_list(). * * @param context A hx509 context. * @param cert a hx509 certificate object. * @param oid an oid to for SubjectAltName. * @param list list of matching SubjectAltName. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_cert */ int hx509_cert_find_subjectAltName_otherName ( hx509_context /*context*/, hx509_cert /*cert*/, const heim_oid */*oid*/, hx509_octet_string_list */*list*/); /** * Free reference to the hx509 certificate object, if the refcounter * reaches 0, the object if freed. Its allowed to pass in NULL. * * @param cert the cert to free. * * @ingroup hx509_cert */ void hx509_cert_free (hx509_cert /*cert*/); /** * Get the SubjectPublicKeyInfo structure from the hx509 certificate. * * @param context a hx509 context. * @param p a hx509 certificate object. * @param spki SubjectPublicKeyInfo, should be freed with * free_SubjectPublicKeyInfo(). * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_cert */ int hx509_cert_get_SPKI ( hx509_context /*context*/, hx509_cert /*p*/, SubjectPublicKeyInfo */*spki*/); /** * Get the AlgorithmIdentifier from the hx509 certificate. * * @param context a hx509 context. * @param p a hx509 certificate object. * @param alg AlgorithmIdentifier, should be freed with * free_AlgorithmIdentifier(). The algorithmidentifier is * typicly rsaEncryption, or id-ecPublicKey, or some other * public key mechanism. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_cert */ int hx509_cert_get_SPKI_AlgorithmIdentifier ( hx509_context /*context*/, hx509_cert /*p*/, AlgorithmIdentifier */*alg*/); /** * Get an external attribute for the certificate, examples are * friendly name and id. * * @param cert hx509 certificate object to search * @param oid an oid to search for. * * @return an hx509_cert_attribute, only valid as long as the * certificate is referenced. * * @ingroup hx509_cert */ hx509_cert_attribute hx509_cert_get_attribute ( hx509_cert /*cert*/, const heim_oid */*oid*/); /** * Return the name of the base subject of the hx509 certificate. If * the certiicate is a verified proxy certificate, the this function * return the base certificate (root of the proxy chain). If the proxy * certificate is not verified with the base certificate * HX509_PROXY_CERTIFICATE_NOT_CANONICALIZED is returned. * * @param context a hx509 context. * @param c a hx509 certificate object. * @param name a pointer to a hx509 name, should be freed by * hx509_name_free(). See also hx509_cert_get_subject(). * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_cert */ int hx509_cert_get_base_subject ( hx509_context /*context*/, hx509_cert /*c*/, hx509_name */*name*/); /** * Get friendly name of the certificate. * * @param cert cert to get the friendly name from. * * @return an friendly name or NULL if there is. The friendly name is * only valid as long as the certificate is referenced. * * @ingroup hx509_cert */ const char * hx509_cert_get_friendly_name (hx509_cert /*cert*/); /** * Return the name of the issuer of the hx509 certificate. * * @param p a hx509 certificate object. * @param name a pointer to a hx509 name, should be freed by * hx509_name_free(). * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_cert */ int hx509_cert_get_issuer ( hx509_cert /*p*/, hx509_name */*name*/); /** * Get a copy of the Issuer Unique ID * * @param context a hx509_context * @param p a hx509 certificate * @param issuer the issuer id returned, free with der_free_bit_string() * * @return An hx509 error code, see hx509_get_error_string(). The * error code HX509_EXTENSION_NOT_FOUND is returned if the certificate * doesn't have a issuerUniqueID * * @ingroup hx509_cert */ int hx509_cert_get_issuer_unique_id ( hx509_context /*context*/, hx509_cert /*p*/, heim_bit_string */*issuer*/); /** * Get notAfter time of the certificate. * * @param p a hx509 certificate object. * * @return return not after time. * * @ingroup hx509_cert */ time_t hx509_cert_get_notAfter (hx509_cert /*p*/); /** * Get notBefore time of the certificate. * * @param p a hx509 certificate object. * * @return return not before time * * @ingroup hx509_cert */ time_t hx509_cert_get_notBefore (hx509_cert /*p*/); /** * Get serial number of the certificate. * * @param p a hx509 certificate object. * @param i serial number, should be freed ith der_free_heim_integer(). * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_cert */ int hx509_cert_get_serialnumber ( hx509_cert /*p*/, heim_integer */*i*/); /** * Return the name of the subject of the hx509 certificate. * * @param p a hx509 certificate object. * @param name a pointer to a hx509 name, should be freed by * hx509_name_free(). See also hx509_cert_get_base_subject(). * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_cert */ int hx509_cert_get_subject ( hx509_cert /*p*/, hx509_name */*name*/); /** * Get a copy of the Subect Unique ID * * @param context a hx509_context * @param p a hx509 certificate * @param subject the subject id returned, free with der_free_bit_string() * * @return An hx509 error code, see hx509_get_error_string(). The * error code HX509_EXTENSION_NOT_FOUND is returned if the certificate * doesn't have a subjectUniqueID * * @ingroup hx509_cert */ int hx509_cert_get_subject_unique_id ( hx509_context /*context*/, hx509_cert /*p*/, heim_bit_string */*subject*/); int hx509_cert_have_private_key (hx509_cert /*p*/); /** * Allocate and init an hx509 certificate object from the decoded * certificate `c´. * * @param context A hx509 context. * @param c * @param error * * @return Returns an hx509 certificate * * @ingroup hx509_cert */ hx509_cert hx509_cert_init ( hx509_context /*context*/, const Certificate */*c*/, heim_error_t */*error*/); /** * Just like hx509_cert_init(), but instead of a decode certificate * takes an pointer and length to a memory region that contains a * DER/BER encoded certificate. * * If the memory region doesn't contain just the certificate and * nothing more the function will fail with * HX509_EXTRA_DATA_AFTER_STRUCTURE. * * @param context A hx509 context. * @param ptr pointer to memory region containing encoded certificate. * @param len length of memory region. * @param error possibly returns an error * * @return An hx509 certificate * * @ingroup hx509_cert */ hx509_cert hx509_cert_init_data ( hx509_context /*context*/, const void */*ptr*/, size_t /*len*/, heim_error_t */*error*/); /** * Print certificate usage for a certificate to a string. * * @param context A hx509 context. * @param c a certificate print the keyusage for. * @param s the return string with the keysage printed in to, free * with hx509_xfree(). * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_print */ int hx509_cert_keyusage_print ( hx509_context /*context*/, hx509_cert /*c*/, char **/*s*/); int hx509_cert_public_encrypt ( hx509_context /*context*/, const heim_octet_string */*cleartext*/, const hx509_cert /*p*/, heim_oid */*encryption_oid*/, heim_octet_string */*ciphertext*/); /** * Add a reference to a hx509 certificate object. * * @param cert a pointer to an hx509 certificate object. * * @return the same object as is passed in. * * @ingroup hx509_cert */ hx509_cert hx509_cert_ref (hx509_cert /*cert*/); /** * Set the friendly name on the certificate. * * @param cert The certificate to set the friendly name on * @param name Friendly name. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_cert */ int hx509_cert_set_friendly_name ( hx509_cert /*cert*/, const char */*name*/); /** * Add a certificate to the certificiate store. * * The receiving keyset certs will either increase reference counter * of the cert or make a deep copy, either way, the caller needs to * free the cert itself. * * @param context a hx509 context. * @param certs certificate store to add the certificate to. * @param cert certificate to add. * * @return Returns an hx509 error code. * * @ingroup hx509_keyset */ int hx509_certs_add ( hx509_context /*context*/, hx509_certs /*certs*/, hx509_cert /*cert*/); /** * Same a hx509_certs_merge() but use a lock and name to describe the * from source. * * @param context a hx509 context. * @param to the store to merge into. * @param lock a lock that unlocks the certificates store, use NULL to * select no password/certifictes/prompt lock (see @ref page_lock). * @param name name of the source store * * @return Returns an hx509 error code. * * @ingroup hx509_keyset */ int hx509_certs_append ( hx509_context /*context*/, hx509_certs /*to*/, hx509_lock /*lock*/, const char */*name*/); /** * End the iteration over certificates. * * @param context a hx509 context. * @param certs certificate store to iterate over. * @param cursor cursor that will keep track of progress, freed. * * @return Returns an hx509 error code. * * @ingroup hx509_keyset */ int hx509_certs_end_seq ( hx509_context /*context*/, hx509_certs /*certs*/, hx509_cursor /*cursor*/); /** * Filter certificate matching the query. * * @param context a hx509 context. * @param certs certificate store to search. * @param q query allocated with @ref hx509_query functions. * @param result the filtered certificate store, caller must free with * hx509_certs_free(). * * @return Returns an hx509 error code. * * @ingroup hx509_keyset */ int hx509_certs_filter ( hx509_context /*context*/, hx509_certs /*certs*/, const hx509_query */*q*/, hx509_certs */*result*/); /** * Find a certificate matching the query. * * @param context a hx509 context. * @param certs certificate store to search. * @param q query allocated with @ref hx509_query functions. * @param r return certificate (or NULL on error), should be freed * with hx509_cert_free(). * * @return Returns an hx509 error code. * * @ingroup hx509_keyset */ int hx509_certs_find ( hx509_context /*context*/, hx509_certs /*certs*/, const hx509_query */*q*/, hx509_cert */*r*/); /** * Free a certificate store. * * @param certs certificate store to free. * * @ingroup hx509_keyset */ void hx509_certs_free (hx509_certs */*certs*/); /** * Print some info about the certificate store. * * @param context a hx509 context. * @param certs certificate store to print information about. * @param func function that will get each line of the information, if * NULL is used the data is printed on a FILE descriptor that should * be passed in ctx, if ctx also is NULL, stdout is used. * @param ctx parameter to func. * * @return Returns an hx509 error code. * * @ingroup hx509_keyset */ int hx509_certs_info ( hx509_context /*context*/, hx509_certs /*certs*/, int (*/*func*/)(void *, const char *), void */*ctx*/); /** * Open or creates a new hx509 certificate store. * * @param context A hx509 context * @param name name of the store, format is TYPE:type-specific-string, * if NULL is used the MEMORY store is used. * @param flags list of flags: * - HX509_CERTS_CREATE create a new keystore of the specific TYPE. * - HX509_CERTS_UNPROTECT_ALL fails if any private key failed to be extracted. * @param lock a lock that unlocks the certificates store, use NULL to * select no password/certifictes/prompt lock (see @ref page_lock). * @param certs return pointer, free with hx509_certs_free(). * * @return Returns an hx509 error code. * * @ingroup hx509_keyset */ int hx509_certs_init ( hx509_context /*context*/, const char */*name*/, int /*flags*/, hx509_lock /*lock*/, hx509_certs */*certs*/); /** * Iterate over all certificates in a keystore and call a block * for each of them. * * @param context a hx509 context. * @param certs certificate store to iterate over. * @param func block to call for each certificate. The function * should return non-zero to abort the iteration, that value is passed * back to the caller of hx509_certs_iter(). * * @return Returns an hx509 error code. * * @ingroup hx509_keyset */ #ifdef __BLOCKS__ int hx509_certs_iter ( hx509_context /*context*/, hx509_certs /*certs*/, int (^func)(hx509_cert)); #endif /* __BLOCKS__ */ /** * Iterate over all certificates in a keystore and call a function * for each of them. * * @param context a hx509 context. * @param certs certificate store to iterate over. * @param func function to call for each certificate. The function * should return non-zero to abort the iteration, that value is passed * back to the caller of hx509_certs_iter_f(). * @param ctx context variable that will passed to the function. * * @return Returns an hx509 error code. * * @ingroup hx509_keyset */ int hx509_certs_iter_f ( hx509_context /*context*/, hx509_certs /*certs*/, int (*/*func*/)(hx509_context, void *, hx509_cert), void */*ctx*/); /** * Merge a certificate store into another. The from store is keep * intact. * * @param context a hx509 context. * @param to the store to merge into. * @param from the store to copy the object from. * * @return Returns an hx509 error code. * * @ingroup hx509_keyset */ int hx509_certs_merge ( hx509_context /*context*/, hx509_certs /*to*/, hx509_certs /*from*/); /** * Get next ceritificate from the certificate keystore pointed out by * cursor. * * @param context a hx509 context. * @param certs certificate store to iterate over. * @param cursor cursor that keeps track of progress. * @param cert return certificate next in store, NULL if the store * contains no more certificates. Free with hx509_cert_free(). * * @return Returns an hx509 error code. * * @ingroup hx509_keyset */ int hx509_certs_next_cert ( hx509_context /*context*/, hx509_certs /*certs*/, hx509_cursor /*cursor*/, hx509_cert */*cert*/); hx509_certs hx509_certs_ref (hx509_certs /*certs*/); /** * Start the integration * * @param context a hx509 context. * @param certs certificate store to iterate over * @param cursor cursor that will keep track of progress, free with * hx509_certs_end_seq(). * * @return Returns an hx509 error code. HX509_UNSUPPORTED_OPERATION is * returned if the certificate store doesn't support the iteration * operation. * * @ingroup hx509_keyset */ int hx509_certs_start_seq ( hx509_context /*context*/, hx509_certs /*certs*/, hx509_cursor */*cursor*/); /** * Write the certificate store to stable storage. * * @param context A hx509 context. * @param certs a certificate store to store. * @param flags currently unused, use 0. * @param lock a lock that unlocks the certificates store, use NULL to * select no password/certifictes/prompt lock (see @ref page_lock). * * @return Returns an hx509 error code. HX509_UNSUPPORTED_OPERATION if * the certificate store doesn't support the store operation. * * @ingroup hx509_keyset */ int hx509_certs_store ( hx509_context /*context*/, hx509_certs /*certs*/, int /*flags*/, hx509_lock /*lock*/); /** * Function to use to hx509_certs_iter_f() as a function argument, the * ctx variable to hx509_certs_iter_f() should be a FILE file descriptor. * * @param context a hx509 context. * @param ctx used by hx509_certs_iter_f(). * @param c a certificate * * @return Returns an hx509 error code. * * @ingroup hx509_keyset */ int hx509_ci_print_names ( hx509_context /*context*/, void */*ctx*/, hx509_cert /*c*/); /** * Resets the error strings the hx509 context. * * @param context A hx509 context. * * @ingroup hx509_error */ void hx509_clear_error_string (hx509_context /*context*/); int hx509_cms_create_signed ( hx509_context /*context*/, int /*flags*/, const heim_oid */*eContentType*/, const void */*data*/, size_t /*length*/, const AlgorithmIdentifier */*digest_alg*/, hx509_certs /*certs*/, hx509_peer_info /*peer*/, hx509_certs /*anchors*/, hx509_certs /*pool*/, heim_octet_string */*signed_data*/); /** * Decode SignedData and verify that the signature is correct. * * @param context A hx509 context. * @param flags * @param eContentType the type of the data. * @param data data to sign * @param length length of the data that data point to. * @param digest_alg digest algorithm to use, use NULL to get the * default or the peer determined algorithm. * @param cert certificate to use for sign the data. * @param peer info about the peer the message to send the message to, * like what digest algorithm to use. * @param anchors trust anchors that the client will use, used to * polulate the certificates included in the message * @param pool certificates to use in try to build the path to the * trust anchors. * @param signed_data the output of the function, free with * der_free_octet_string(). * * @return Returns an hx509 error code. * * @ingroup hx509_cms */ int hx509_cms_create_signed_1 ( hx509_context /*context*/, int /*flags*/, const heim_oid */*eContentType*/, const void */*data*/, size_t /*length*/, const AlgorithmIdentifier */*digest_alg*/, hx509_cert /*cert*/, hx509_peer_info /*peer*/, hx509_certs /*anchors*/, hx509_certs /*pool*/, heim_octet_string */*signed_data*/); /** * Use HX509_CMS_SIGNATURE_NO_SIGNER to create no sigInfo (no * signatures). */ int hx509_cms_decrypt_encrypted ( hx509_context /*context*/, hx509_lock /*lock*/, const void */*data*/, size_t /*length*/, heim_oid */*contentType*/, heim_octet_string */*content*/); /** * Encrypt end encode EnvelopedData. * * Encrypt and encode EnvelopedData. The data is encrypted with a * random key and the the random key is encrypted with the * certificates private key. This limits what private key type can be * used to RSA. * * @param context A hx509 context. * @param flags flags to control the behavior. * - HX509_CMS_EV_NO_KU_CHECK - Don't check KU on certificate * - HX509_CMS_EV_ALLOW_WEAK - Allow weak crytpo * - HX509_CMS_EV_ID_NAME - prefer issuer name and serial number * @param cert Certificate to encrypt the EnvelopedData encryption key * with. * @param data pointer the data to encrypt. * @param length length of the data that data point to. * @param encryption_type Encryption cipher to use for the bulk data, * use NULL to get default. * @param contentType type of the data that is encrypted * @param content the output of the function, * free with der_free_octet_string(). * * @return an hx509 error code. * * @ingroup hx509_cms */ int hx509_cms_envelope_1 ( hx509_context /*context*/, int /*flags*/, hx509_cert /*cert*/, const void */*data*/, size_t /*length*/, const heim_oid */*encryption_type*/, const heim_oid */*contentType*/, heim_octet_string */*content*/); /** * Decode and unencrypt EnvelopedData. * * Extract data and parameteres from from the EnvelopedData. Also * supports using detached EnvelopedData. * * @param context A hx509 context. * @param certs Certificate that can decrypt the EnvelopedData * encryption key. * @param flags HX509_CMS_UE flags to control the behavior. * @param data pointer the structure the contains the DER/BER encoded * EnvelopedData stucture. * @param length length of the data that data point to. * @param encryptedContent in case of detached signature, this * contains the actual encrypted data, othersize its should be NULL. * @param time_now set the current time, if zero the library uses now as the date. * @param contentType output type oid, should be freed with der_free_oid(). * @param content the data, free with der_free_octet_string(). * * @return an hx509 error code. * * @ingroup hx509_cms */ int hx509_cms_unenvelope ( hx509_context /*context*/, hx509_certs /*certs*/, int /*flags*/, const void */*data*/, size_t /*length*/, const heim_octet_string */*encryptedContent*/, time_t /*time_now*/, heim_oid */*contentType*/, heim_octet_string */*content*/); /** * Decode an ContentInfo and unwrap data and oid it. * * @param in the encoded buffer. * @param oid type of the content. * @param out data to be wrapped. * @param have_data since the data is optional, this flags show dthe * diffrence between no data and the zero length data. * * @return Returns an hx509 error code. * * @ingroup hx509_cms */ int hx509_cms_unwrap_ContentInfo ( const heim_octet_string */*in*/, heim_oid */*oid*/, heim_octet_string */*out*/, int */*have_data*/); /** * Decode SignedData and verify that the signature is correct. * * @param context A hx509 context. * @param ctx a hx509 verify context. * @param flags to control the behaivor of the function. * - HX509_CMS_VS_NO_KU_CHECK - Don't check KeyUsage * - HX509_CMS_VS_ALLOW_DATA_OID_MISMATCH - allow oid mismatch * - HX509_CMS_VS_ALLOW_ZERO_SIGNER - no signer, see below. * @param data pointer to CMS SignedData encoded data. * @param length length of the data that data point to. * @param signedContent external data used for signature. * @param pool certificate pool to build certificates paths. * @param contentType free with der_free_oid(). * @param content the output of the function, free with * der_free_octet_string(). * @param signer_certs list of the cerficates used to sign this * request, free with hx509_certs_free(). * * @return an hx509 error code. * * @ingroup hx509_cms */ int hx509_cms_verify_signed ( hx509_context /*context*/, hx509_verify_ctx /*ctx*/, unsigned int /*flags*/, const void */*data*/, size_t /*length*/, const heim_octet_string */*signedContent*/, hx509_certs /*pool*/, heim_oid */*contentType*/, heim_octet_string */*content*/, hx509_certs */*signer_certs*/); /** * Wrap data and oid in a ContentInfo and encode it. * * @param oid type of the content. * @param buf data to be wrapped. If a NULL pointer is passed in, the * optional content field in the ContentInfo is not going be filled * in. * @param res the encoded buffer, the result should be freed with * der_free_octet_string(). * * @return Returns an hx509 error code. * * @ingroup hx509_cms */ int hx509_cms_wrap_ContentInfo ( const heim_oid */*oid*/, const heim_octet_string */*buf*/, heim_octet_string */*res*/); /** * Free the context allocated by hx509_context_init(). * * @param context context to be freed. * * @ingroup hx509 */ void hx509_context_free (hx509_context */*context*/); /** * Creates a hx509 context that most functions in the library * uses. The context is only allowed to be used by one thread at each * moment. Free the context with hx509_context_free(). * * @param context Returns a pointer to new hx509 context. * * @return Returns an hx509 error code. * * @ingroup hx509 */ int hx509_context_init (hx509_context */*context*/); /** * Selects if the hx509_revoke_verify() function is going to require * the existans of a revokation method (OCSP, CRL) or not. Note that * hx509_verify_path(), hx509_cms_verify_signed(), and other function * call hx509_revoke_verify(). * * @param context hx509 context to change the flag for. * @param flag zero, revokation method required, non zero missing * revokation method ok * * @ingroup hx509_verify */ void hx509_context_set_missing_revoke ( hx509_context /*context*/, int /*flag*/); /** * Add revoked certificate to an CRL context. * * @param context a hx509 context. * @param crl the CRL to add the revoked certificate to. * @param certs keyset of certificate to revoke. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_verify */ int hx509_crl_add_revoked_certs ( hx509_context /*context*/, hx509_crl /*crl*/, hx509_certs /*certs*/); /** * Create a CRL context. Use hx509_crl_free() to free the CRL context. * * @param context a hx509 context. * @param crl return pointer to a newly allocated CRL context. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_verify */ int hx509_crl_alloc ( hx509_context /*context*/, hx509_crl */*crl*/); /** * Free a CRL context. * * @param context a hx509 context. * @param crl a CRL context to free. * * @ingroup hx509_verify */ void hx509_crl_free ( hx509_context /*context*/, hx509_crl */*crl*/); /** * Set the lifetime of a CRL context. * * @param context a hx509 context. * @param crl a CRL context * @param delta delta time the certificate is valid, library adds the * current time to this. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_verify */ int hx509_crl_lifetime ( hx509_context /*context*/, hx509_crl /*crl*/, int /*delta*/); /** * Sign a CRL and return an encode certificate. * * @param context a hx509 context. * @param signer certificate to sign the CRL with * @param crl the CRL to sign * @param os return the signed and encoded CRL, free with * free_heim_octet_string() * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_verify */ int hx509_crl_sign ( hx509_context /*context*/, hx509_cert /*signer*/, hx509_crl /*crl*/, heim_octet_string */*os*/); const AlgorithmIdentifier * hx509_crypto_aes128_cbc (void); const AlgorithmIdentifier * hx509_crypto_aes256_cbc (void); void hx509_crypto_allow_weak (hx509_crypto /*crypto*/); int hx509_crypto_available ( hx509_context /*context*/, int /*type*/, hx509_cert /*source*/, AlgorithmIdentifier **/*val*/, unsigned int */*plen*/); int hx509_crypto_decrypt ( hx509_crypto /*crypto*/, const void */*data*/, const size_t /*length*/, heim_octet_string */*ivec*/, heim_octet_string */*clear*/); const AlgorithmIdentifier * hx509_crypto_des_rsdi_ede3_cbc (void); void hx509_crypto_destroy (hx509_crypto /*crypto*/); int hx509_crypto_encrypt ( hx509_crypto /*crypto*/, const void */*data*/, const size_t /*length*/, const heim_octet_string */*ivec*/, heim_octet_string **/*ciphertext*/); const heim_oid * hx509_crypto_enctype_by_name (const char */*name*/); void hx509_crypto_free_algs ( AlgorithmIdentifier */*val*/, unsigned int /*len*/); int hx509_crypto_get_params ( hx509_context /*context*/, hx509_crypto /*crypto*/, const heim_octet_string */*ivec*/, heim_octet_string */*param*/); int hx509_crypto_init ( hx509_context /*context*/, const char */*provider*/, const heim_oid */*enctype*/, hx509_crypto */*crypto*/); const char * hx509_crypto_provider (hx509_crypto /*crypto*/); int hx509_crypto_random_iv ( hx509_crypto /*crypto*/, heim_octet_string */*ivec*/); int hx509_crypto_select ( const hx509_context /*context*/, int /*type*/, const hx509_private_key /*source*/, hx509_peer_info /*peer*/, AlgorithmIdentifier */*selected*/); int hx509_crypto_set_key_data ( hx509_crypto /*crypto*/, const void */*data*/, size_t /*length*/); int hx509_crypto_set_key_name ( hx509_crypto /*crypto*/, const char */*name*/); void hx509_crypto_set_padding ( hx509_crypto /*crypto*/, int /*padding_type*/); int hx509_crypto_set_params ( hx509_context /*context*/, hx509_crypto /*crypto*/, const heim_octet_string */*param*/, heim_octet_string */*ivec*/); int hx509_crypto_set_random_key ( hx509_crypto /*crypto*/, heim_octet_string */*key*/); /** * Add a new key/value pair to the hx509_env. * * @param context A hx509 context. * @param env environment to add the environment variable too. * @param key key to add * @param value value to add * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_env */ int hx509_env_add ( hx509_context /*context*/, hx509_env */*env*/, const char */*key*/, const char */*value*/); /** * Add a new key/binding pair to the hx509_env. * * @param context A hx509 context. * @param env environment to add the environment variable too. * @param key key to add * @param list binding list to add * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_env */ int hx509_env_add_binding ( hx509_context /*context*/, hx509_env */*env*/, const char */*key*/, hx509_env /*list*/); /** * Search the hx509_env for a key. * * @param context A hx509 context. * @param env environment to add the environment variable too. * @param key key to search for. * * @return the value if the key is found, NULL otherwise. * * @ingroup hx509_env */ const char * hx509_env_find ( hx509_context /*context*/, hx509_env /*env*/, const char */*key*/); /** * Search the hx509_env for a binding. * * @param context A hx509 context. * @param env environment to add the environment variable too. * @param key key to search for. * * @return the binding if the key is found, NULL if not found. * * @ingroup hx509_env */ hx509_env hx509_env_find_binding ( hx509_context /*context*/, hx509_env /*env*/, const char */*key*/); /** * Free an hx509_env environment context. * * @param env the environment to free. * * @ingroup hx509_env */ void hx509_env_free (hx509_env */*env*/); /** * Search the hx509_env for a length based key. * * @param context A hx509 context. * @param env environment to add the environment variable too. * @param key key to search for. * @param len length of key. * * @return the value if the key is found, NULL otherwise. * * @ingroup hx509_env */ const char * hx509_env_lfind ( hx509_context /*context*/, hx509_env /*env*/, const char */*key*/, size_t /*len*/); /** * Print error message and fatally exit from error code * * @param context A hx509 context. * @param exit_code exit() code from process. * @param error_code Error code for the reason to exit. * @param fmt format string with the exit message. * @param ... argument to format string. * * @ingroup hx509_error */ void hx509_err ( hx509_context /*context*/, int /*exit_code*/, int /*error_code*/, const char */*fmt*/, ...); hx509_private_key_ops * hx509_find_private_alg (const heim_oid */*oid*/); /** * Free error string returned by hx509_get_error_string(). * * @param str error string to free. * * @ingroup hx509_error */ void hx509_free_error_string (char */*str*/); /** * Free a list of octet strings returned by another hx509 library * function. * * @param list list to be freed. * * @ingroup hx509_misc */ void hx509_free_octet_string_list (hx509_octet_string_list */*list*/); /** * Unparse the hx509 name in name into a string. * * @param name the name to print * @param str an allocated string returns the name in string form * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_name */ int hx509_general_name_unparse ( GeneralName */*name*/, char **/*str*/); /** * Get an error string from context associated with error_code. * * @param context A hx509 context. * @param error_code Get error message for this error code. * * @return error string, free with hx509_free_error_string(). * * @ingroup hx509_error */ char * hx509_get_error_string ( hx509_context /*context*/, int /*error_code*/); /** * Get one random certificate from the certificate store. * * @param context a hx509 context. * @param certs a certificate store to get the certificate from. * @param c return certificate, should be freed with hx509_cert_free(). * * @return Returns an hx509 error code. * * @ingroup hx509_keyset */ int hx509_get_one_cert ( hx509_context /*context*/, hx509_certs /*certs*/, hx509_cert */*c*/); int hx509_lock_add_cert ( hx509_context /*context*/, hx509_lock /*lock*/, hx509_cert /*cert*/); int hx509_lock_add_certs ( hx509_context /*context*/, hx509_lock /*lock*/, hx509_certs /*certs*/); int hx509_lock_add_password ( hx509_lock /*lock*/, const char */*password*/); int hx509_lock_command_string ( hx509_lock /*lock*/, const char */*string*/); void hx509_lock_free (hx509_lock /*lock*/); /** * @page page_lock Locking and unlocking certificates and encrypted data. * * See the library functions here: @ref hx509_lock */ int hx509_lock_init ( hx509_context /*context*/, hx509_lock */*lock*/); int hx509_lock_prompt ( hx509_lock /*lock*/, hx509_prompt */*prompt*/); void hx509_lock_reset_certs ( hx509_context /*context*/, hx509_lock /*lock*/); void hx509_lock_reset_passwords (hx509_lock /*lock*/); void hx509_lock_reset_promper (hx509_lock /*lock*/); int hx509_lock_set_prompter ( hx509_lock /*lock*/, hx509_prompter_fct /*prompt*/, void */*data*/); /** * Convert a hx509_name object to DER encoded name. * * @param name name to concert * @param os data to a DER encoded name, free the resulting octet * string with hx509_xfree(os->data). * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_name */ int hx509_name_binary ( const hx509_name /*name*/, heim_octet_string */*os*/); /** * Compare to hx509 name object, useful for sorting. * * @param n1 a hx509 name object. * @param n2 a hx509 name object. * * @return 0 the objects are the same, returns > 0 is n2 is "larger" * then n2, < 0 if n1 is "smaller" then n2. * * @ingroup hx509_name */ int hx509_name_cmp ( hx509_name /*n1*/, hx509_name /*n2*/); /** * Copy a hx509 name object. * * @param context A hx509 cotext. * @param from the name to copy from * @param to the name to copy to * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_name */ int hx509_name_copy ( hx509_context /*context*/, const hx509_name /*from*/, hx509_name */*to*/); /** * Expands variables in the name using env. Variables are on the form * ${name}. Useful when dealing with certificate templates. * * @param context A hx509 cotext. * @param name the name to expand. * @param env environment variable to expand. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_name */ int hx509_name_expand ( hx509_context /*context*/, hx509_name /*name*/, hx509_env /*env*/); /** * Free a hx509 name object, upond return *name will be NULL. * * @param name a hx509 name object to be freed. * * @ingroup hx509_name */ void hx509_name_free (hx509_name */*name*/); /** * Unparse the hx509 name in name into a string. * * @param name the name to check if its empty/null. * * @return non zero if the name is empty/null. * * @ingroup hx509_name */ int hx509_name_is_null_p (const hx509_name /*name*/); int hx509_name_normalize ( hx509_context /*context*/, hx509_name /*name*/); /** * Convert a hx509_name into a Name. * * @param from the name to copy from * @param to the name to copy to * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_name */ int hx509_name_to_Name ( const hx509_name /*from*/, Name */*to*/); /** * Convert the hx509 name object into a printable string. * The resulting string should be freed with free(). * * @param name name to print * @param str the string to return * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_name */ int hx509_name_to_string ( const hx509_name /*name*/, char **/*str*/); /** * Create an OCSP request for a set of certificates. * * @param context a hx509 context * @param reqcerts list of certificates to request ocsp data for * @param pool certificate pool to use when signing * @param signer certificate to use to sign the request * @param digest the signing algorithm in the request, if NULL use the * default signature algorithm, * @param request the encoded request, free with free_heim_octet_string(). * @param nonce nonce in the request, free with free_heim_octet_string(). * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_revoke */ int hx509_ocsp_request ( hx509_context /*context*/, hx509_certs /*reqcerts*/, hx509_certs /*pool*/, hx509_cert /*signer*/, const AlgorithmIdentifier */*digest*/, heim_octet_string */*request*/, heim_octet_string */*nonce*/); /** * Verify that the certificate is part of the OCSP reply and it's not * expired. Doesn't verify signature the OCSP reply or it's done by a * authorized sender, that is assumed to be already done. * * @param context a hx509 context * @param now the time right now, if 0, use the current time. * @param cert the certificate to verify * @param flags flags control the behavior * @param data pointer to the encode ocsp reply * @param length the length of the encode ocsp reply * @param expiration return the time the OCSP will expire and need to * be rechecked. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_verify */ int hx509_ocsp_verify ( hx509_context /*context*/, time_t /*now*/, hx509_cert /*cert*/, int /*flags*/, const void */*data*/, size_t /*length*/, time_t */*expiration*/); /** * Print a oid using a hx509_vprint_func function. To print to stdout * use hx509_print_stdout(). * * @param oid oid to print * @param func hx509_vprint_func to print with. * @param ctx context variable to hx509_vprint_func function. * * @ingroup hx509_print */ void hx509_oid_print ( const heim_oid */*oid*/, hx509_vprint_func /*func*/, void */*ctx*/); /** * Print a oid to a string. * * @param oid oid to print * @param str allocated string, free with hx509_xfree(). * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_print */ int hx509_oid_sprint ( const heim_oid */*oid*/, char **/*str*/); /** * Parse a string into a hx509 name object. * * @param context A hx509 context. * @param str a string to parse. * @param name the resulting object, NULL in case of error. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_name */ int hx509_parse_name ( hx509_context /*context*/, const char */*str*/, hx509_name */*name*/); int hx509_parse_private_key ( hx509_context /*context*/, const AlgorithmIdentifier */*keyai*/, const void */*data*/, size_t /*len*/, hx509_key_format_t /*format*/, hx509_private_key */*private_key*/); /** * Add an additional algorithm that the peer supports. * * @param context A hx509 context. * @param peer the peer to set the new algorithms for * @param val an AlgorithmsIdentier to add * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_peer */ int hx509_peer_info_add_cms_alg ( hx509_context /*context*/, hx509_peer_info /*peer*/, const AlgorithmIdentifier */*val*/); /** * Allocate a new peer info structure an init it to default values. * * @param context A hx509 context. * @param peer return an allocated peer, free with hx509_peer_info_free(). * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_peer */ int hx509_peer_info_alloc ( hx509_context /*context*/, hx509_peer_info */*peer*/); /** * Free a peer info structure. * * @param peer peer info to be freed. * * @ingroup hx509_peer */ void hx509_peer_info_free (hx509_peer_info /*peer*/); /** * Set the certificate that remote peer is using. * * @param peer peer info to update * @param cert cerificate of the remote peer. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_peer */ int hx509_peer_info_set_cert ( hx509_peer_info /*peer*/, hx509_cert /*cert*/); /** * Set the algorithms that the peer supports. * * @param context A hx509 context. * @param peer the peer to set the new algorithms for * @param val array of supported AlgorithmsIdentiers * @param len length of array val. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_peer */ int hx509_peer_info_set_cms_algs ( hx509_context /*context*/, hx509_peer_info /*peer*/, const AlgorithmIdentifier */*val*/, size_t /*len*/); int hx509_pem_add_header ( hx509_pem_header **/*headers*/, const char */*header*/, const char */*value*/); const char * hx509_pem_find_header ( const hx509_pem_header */*h*/, const char */*header*/); void hx509_pem_free_header (hx509_pem_header */*headers*/); int hx509_pem_read ( hx509_context /*context*/, FILE */*f*/, hx509_pem_read_func /*func*/, void */*ctx*/); int hx509_pem_write ( hx509_context /*context*/, const char */*type*/, hx509_pem_header */*headers*/, FILE */*f*/, const void */*data*/, size_t /*size*/); /** * Print a simple representation of a certificate * * @param context A hx509 context, can be NULL * @param cert certificate to print * @param out the stdio output stream, if NULL, stdout is used * * @return An hx509 error code * * @ingroup hx509_cert */ int hx509_print_cert ( hx509_context /*context*/, hx509_cert /*cert*/, FILE */*out*/); /** * Helper function to print on stdout for: * - hx509_oid_print(), * - hx509_bitstring_print(), * - hx509_validate_ctx_set_print(). * * @param ctx the context to the print function. If the ctx is NULL, * stdout is used. * @param fmt the printing format. * @param va the argumet list. * * @ingroup hx509_print */ void hx509_print_stdout ( void */*ctx*/, const char */*fmt*/, va_list /*va*/); int hx509_private_key2SPKI ( hx509_context /*context*/, hx509_private_key /*private_key*/, SubjectPublicKeyInfo */*spki*/); void hx509_private_key_assign_rsa ( hx509_private_key /*key*/, void */*ptr*/); int hx509_private_key_free (hx509_private_key */*key*/); int hx509_private_key_init ( hx509_private_key */*key*/, hx509_private_key_ops */*ops*/, void */*keydata*/); int hx509_private_key_private_decrypt ( hx509_context /*context*/, const heim_octet_string */*ciphertext*/, const heim_oid */*encryption_oid*/, hx509_private_key /*p*/, heim_octet_string */*cleartext*/); int hx509_prompt_hidden (hx509_prompt_type /*type*/); /** * Allocate an query controller. Free using hx509_query_free(). * * @param context A hx509 context. * @param q return pointer to a hx509_query. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_cert */ int hx509_query_alloc ( hx509_context /*context*/, hx509_query **/*q*/); /** * Free the query controller. * * @param context A hx509 context. * @param q a pointer to the query controller. * * @ingroup hx509_cert */ void hx509_query_free ( hx509_context /*context*/, hx509_query */*q*/); /** * Set the query controller to match using a specific match function. * * @param q a hx509 query controller. * @param func function to use for matching, if the argument is NULL, * the match function is removed. * @param ctx context passed to the function. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_cert */ int hx509_query_match_cmp_func ( hx509_query */*q*/, int (*/*func*/)(hx509_context, hx509_cert, void *), void */*ctx*/); /** * Set the query controller to require an one specific EKU (extended * key usage). Any previous EKU matching is overwitten. If NULL is * passed in as the eku, the EKU requirement is reset. * * @param q a hx509 query controller. * @param eku an EKU to match on. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_cert */ int hx509_query_match_eku ( hx509_query */*q*/, const heim_oid */*eku*/); int hx509_query_match_expr ( hx509_context /*context*/, hx509_query */*q*/, const char */*expr*/); /** * Set the query controller to match on a friendly name * * @param q a hx509 query controller. * @param name a friendly name to match on * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_cert */ int hx509_query_match_friendly_name ( hx509_query */*q*/, const char */*name*/); /** * Set the issuer and serial number of match in the query * controller. The function make copies of the isser and serial number. * * @param q a hx509 query controller * @param issuer issuer to search for * @param serialNumber the serialNumber of the issuer. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_cert */ int hx509_query_match_issuer_serial ( hx509_query */*q*/, const Name */*issuer*/, const heim_integer */*serialNumber*/); /** * Set match options for the hx509 query controller. * * @param q query controller. * @param option options to control the query controller. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_cert */ void hx509_query_match_option ( hx509_query */*q*/, hx509_query_option /*option*/); /** * Set a statistic file for the query statistics. * * @param context A hx509 context. * @param fn statistics file name * * @ingroup hx509_cert */ void hx509_query_statistic_file ( hx509_context /*context*/, const char */*fn*/); /** * Unparse the statistics file and print the result on a FILE descriptor. * * @param context A hx509 context. * @param printtype tyep to print * @param out the FILE to write the data on. * * @ingroup hx509_cert */ void hx509_query_unparse_stats ( hx509_context /*context*/, int /*printtype*/, FILE */*out*/); void hx509_request_free (hx509_request */*req*/); int hx509_request_get_SubjectPublicKeyInfo ( hx509_context /*context*/, hx509_request /*req*/, SubjectPublicKeyInfo */*key*/); int hx509_request_get_name ( hx509_context /*context*/, hx509_request /*req*/, hx509_name */*name*/); int hx509_request_init ( hx509_context /*context*/, hx509_request */*req*/); int hx509_request_set_SubjectPublicKeyInfo ( hx509_context /*context*/, hx509_request /*req*/, const SubjectPublicKeyInfo */*key*/); int hx509_request_set_name ( hx509_context /*context*/, hx509_request /*req*/, hx509_name /*name*/); /** * Add a CRL file to the revokation context. * * @param context hx509 context * @param ctx hx509 revokation context * @param path path to file that is going to be added to the context. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_revoke */ int hx509_revoke_add_crl ( hx509_context /*context*/, hx509_revoke_ctx /*ctx*/, const char */*path*/); /** * Add a OCSP file to the revokation context. * * @param context hx509 context * @param ctx hx509 revokation context * @param path path to file that is going to be added to the context. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_revoke */ int hx509_revoke_add_ocsp ( hx509_context /*context*/, hx509_revoke_ctx /*ctx*/, const char */*path*/); /** * Free a hx509 revokation context. * * @param ctx context to be freed * * @ingroup hx509_revoke */ void hx509_revoke_free (hx509_revoke_ctx */*ctx*/); /** * Allocate a revokation context. Free with hx509_revoke_free(). * * @param context A hx509 context. * @param ctx returns a newly allocated revokation context. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_revoke */ int hx509_revoke_init ( hx509_context /*context*/, hx509_revoke_ctx */*ctx*/); /** * Print the OCSP reply stored in a file. * * @param context a hx509 context * @param path path to a file with a OCSP reply * @param out the out FILE descriptor to print the reply on * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_revoke */ int hx509_revoke_ocsp_print ( hx509_context /*context*/, const char */*path*/, FILE */*out*/); int hx509_revoke_print ( hx509_context /*context*/, hx509_revoke_ctx /*ctx*/, FILE */*out*/); /** * Check that a certificate is not expired according to a revokation * context. Also need the parent certificte to the check OCSP * parent identifier. * * @param context hx509 context * @param ctx hx509 revokation context * @param certs * @param now * @param cert * @param parent_cert * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_revoke */ int hx509_revoke_verify ( hx509_context /*context*/, hx509_revoke_ctx /*ctx*/, hx509_certs /*certs*/, time_t /*now*/, hx509_cert /*cert*/, hx509_cert /*parent_cert*/); /** * See hx509_set_error_stringv(). * * @param context A hx509 context. * @param flags * - HX509_ERROR_APPEND appends the error string to the old messages (code is updated). * @param code error code related to error message * @param fmt error message format * @param ... arguments to error message format * * @ingroup hx509_error */ void hx509_set_error_string ( hx509_context /*context*/, int /*flags*/, int /*code*/, const char */*fmt*/, ...); /** * Add an error message to the hx509 context. * * @param context A hx509 context. * @param flags * - HX509_ERROR_APPEND appends the error string to the old messages (code is updated). * @param code error code related to error message * @param fmt error message format * @param ap arguments to error message format * * @ingroup hx509_error */ void hx509_set_error_stringv ( hx509_context /*context*/, int /*flags*/, int /*code*/, const char */*fmt*/, va_list /*ap*/); const AlgorithmIdentifier * hx509_signature_ecPublicKey (void); const AlgorithmIdentifier * hx509_signature_ecdsa_with_sha256 (void); const AlgorithmIdentifier * hx509_signature_md5 (void); const AlgorithmIdentifier * hx509_signature_rsa (void); const AlgorithmIdentifier * hx509_signature_rsa_pkcs1_x509 (void); const AlgorithmIdentifier * hx509_signature_rsa_with_md5 (void); const AlgorithmIdentifier * hx509_signature_rsa_with_sha1 (void); const AlgorithmIdentifier * hx509_signature_rsa_with_sha256 (void); const AlgorithmIdentifier * hx509_signature_rsa_with_sha384 (void); const AlgorithmIdentifier * hx509_signature_rsa_with_sha512 (void); const AlgorithmIdentifier * hx509_signature_sha1 (void); const AlgorithmIdentifier * hx509_signature_sha256 (void); const AlgorithmIdentifier * hx509_signature_sha384 (void); const AlgorithmIdentifier * hx509_signature_sha512 (void); /** * Convert a DER encoded name info a string. * * @param data data to a DER/BER encoded name * @param length length of data * @param str the resulting string, is NULL on failure. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_name */ int hx509_unparse_der_name ( const void */*data*/, size_t /*length*/, char **/*str*/); /** * Validate/Print the status of the certificate. * * @param context A hx509 context. * @param ctx A hx509 validation context. * @param cert the cerificate to validate/print. * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_print */ int hx509_validate_cert ( hx509_context /*context*/, hx509_validate_ctx /*ctx*/, hx509_cert /*cert*/); /** * Add flags to control the behaivor of the hx509_validate_cert() * function. * * @param ctx A hx509 validation context. * @param flags flags to add to the validation context. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_print */ void hx509_validate_ctx_add_flags ( hx509_validate_ctx /*ctx*/, int /*flags*/); /** * Free an hx509 validate context. * * @param ctx the hx509 validate context to free. * * @ingroup hx509_print */ void hx509_validate_ctx_free (hx509_validate_ctx /*ctx*/); /** * Allocate a hx509 validation/printing context. * * @param context A hx509 context. * @param ctx a new allocated hx509 validation context, free with * hx509_validate_ctx_free(). * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_print */ int hx509_validate_ctx_init ( hx509_context /*context*/, hx509_validate_ctx */*ctx*/); /** * Set the printing functions for the validation context. * * @param ctx a hx509 valication context. * @param func the printing function to usea. * @param c the context variable to the printing function. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_print */ void hx509_validate_ctx_set_print ( hx509_validate_ctx /*ctx*/, hx509_vprint_func /*func*/, void */*c*/); /** * Set the trust anchors in the verification context, makes an * reference to the keyset, so the consumer can free the keyset * independent of the destruction of the verification context (ctx). * If there already is a keyset attached, it's released. * * @param ctx a verification context * @param set a keyset containing the trust anchors. * * @ingroup hx509_verify */ void hx509_verify_attach_anchors ( hx509_verify_ctx /*ctx*/, hx509_certs /*set*/); /** * Attach an revocation context to the verfication context, , makes an * reference to the revoke context, so the consumer can free the * revoke context independent of the destruction of the verification * context. If there is no revoke context, the verification process is * NOT going to check any verification status. * * @param ctx a verification context. * @param revoke_ctx a revoke context. * * @ingroup hx509_verify */ void hx509_verify_attach_revoke ( hx509_verify_ctx /*ctx*/, hx509_revoke_ctx /*revoke_ctx*/); void hx509_verify_ctx_f_allow_best_before_signature_algs ( hx509_context /*ctx*/, int /*boolean*/); /** * Allow using the operating system builtin trust anchors if no other * trust anchors are configured. * * @param ctx a verification context * @param boolean if non zero, useing the operating systems builtin * trust anchors. * * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_cert */ void hx509_verify_ctx_f_allow_default_trustanchors ( hx509_verify_ctx /*ctx*/, int /*boolean*/); /** * Free an hx509 verification context. * * @param ctx the context to be freed. * * @ingroup hx509_verify */ void hx509_verify_destroy_ctx (hx509_verify_ctx /*ctx*/); /** * Verify that the certificate is allowed to be used for the hostname * and address. * * @param context A hx509 context. * @param cert the certificate to match with * @param flags Flags to modify the behavior: * - HX509_VHN_F_ALLOW_NO_MATCH no match is ok * @param type type of hostname: * - HX509_HN_HOSTNAME for plain hostname. * - HX509_HN_DNSSRV for DNS SRV names. * @param hostname the hostname to check * @param sa address of the host * @param sa_size length of address * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_cert */ int hx509_verify_hostname ( hx509_context /*context*/, const hx509_cert /*cert*/, int /*flags*/, hx509_hostname_type /*type*/, const char */*hostname*/, const struct sockaddr */*sa*/, int /*sa_size*/); /** * Allocate an verification context that is used fo control the * verification process. * * @param context A hx509 context. * @param ctx returns a pointer to a hx509_verify_ctx object. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_verify */ int hx509_verify_init_ctx ( hx509_context /*context*/, hx509_verify_ctx */*ctx*/); /** * Build and verify the path for the certificate to the trust anchor * specified in the verify context. The path is constructed from the * certificate, the pool and the trust anchors. * * @param context A hx509 context. * @param ctx A hx509 verification context. * @param cert the certificate to build the path from. * @param pool A keyset of certificates to build the chain from. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_verify */ int hx509_verify_path ( hx509_context /*context*/, hx509_verify_ctx /*ctx*/, hx509_cert /*cert*/, hx509_certs /*pool*/); /** * Set the maximum depth of the certificate chain that the path * builder is going to try. * * @param ctx a verification context * @param max_depth maxium depth of the certificate chain, include * trust anchor. * * @ingroup hx509_verify */ void hx509_verify_set_max_depth ( hx509_verify_ctx /*ctx*/, unsigned int /*max_depth*/); /** * Allow or deny the use of proxy certificates * * @param ctx a verification context * @param boolean if non zero, allow proxy certificates. * * @ingroup hx509_verify */ void hx509_verify_set_proxy_certificate ( hx509_verify_ctx /*ctx*/, int /*boolean*/); /** * Select strict RFC3280 verification of certificiates. This means * checking key usage on CA certificates, this will make version 1 * certificiates unuseable. * * @param ctx a verification context * @param boolean if non zero, use strict verification. * * @ingroup hx509_verify */ void hx509_verify_set_strict_rfc3280_verification ( hx509_verify_ctx /*ctx*/, int /*boolean*/); /** * Set the clock time the the verification process is going to * use. Used to check certificate in the past and future time. If not * set the current time will be used. * * @param ctx a verification context. * @param t the time the verifiation is using. * * * @ingroup hx509_verify */ void hx509_verify_set_time ( hx509_verify_ctx /*ctx*/, time_t /*t*/); /** * Verify a signature made using the private key of an certificate. * * @param context A hx509 context. * @param signer the certificate that made the signature. * @param alg algorthm that was used to sign the data. * @param data the data that was signed. * @param sig the sigature to verify. * * @return An hx509 error code, see hx509_get_error_string(). * * @ingroup hx509_crypto */ int hx509_verify_signature ( hx509_context /*context*/, const hx509_cert /*signer*/, const AlgorithmIdentifier */*alg*/, const heim_octet_string */*data*/, const heim_octet_string */*sig*/); /** * Free a data element allocated in the library. * * @param ptr data to be freed. * * @ingroup hx509_misc */ void hx509_xfree (void */*ptr*/); int yywrap (void); #ifdef __cplusplus } #endif #endif /* DOXY */ #endif /* __hx509_protos_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/hx509.h000066400000000000000000000136361505521762700216530ustar00rootroot00000000000000/* * Copyright (c) 2004 - 2007 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef HEIMDAL_HX509_H #define HEIMDAL_HX509_H 1 #include #include #include #include typedef struct hx509_cert_attribute_data *hx509_cert_attribute; typedef struct hx509_cert_data *hx509_cert; typedef struct hx509_certs_data *hx509_certs; typedef struct hx509_context_data *hx509_context; typedef struct hx509_crypto_data *hx509_crypto; typedef struct hx509_lock_data *hx509_lock; typedef struct hx509_name_data *hx509_name; typedef struct hx509_private_key *hx509_private_key; typedef struct hx509_private_key_ops hx509_private_key_ops; typedef struct hx509_validate_ctx_data *hx509_validate_ctx; typedef struct hx509_verify_ctx_data *hx509_verify_ctx; typedef struct hx509_revoke_ctx_data *hx509_revoke_ctx; typedef struct hx509_query_data hx509_query; typedef void * hx509_cursor; typedef struct hx509_request_data *hx509_request; typedef struct hx509_error_data *hx509_error; typedef struct hx509_peer_info *hx509_peer_info; typedef struct hx509_ca_tbs *hx509_ca_tbs; typedef struct hx509_env_data *hx509_env; typedef struct hx509_crl *hx509_crl; typedef void (*hx509_vprint_func)(void *, const char *, va_list); enum { HX509_VHN_F_ALLOW_NO_MATCH = 1 }; enum { HX509_VALIDATE_F_VALIDATE = 1, HX509_VALIDATE_F_VERBOSE = 2 }; enum { HX509_CRYPTO_PADDING_PKCS7 = 0, HX509_CRYPTO_PADDING_NONE = 1 }; enum { HX509_KEY_FORMAT_GUESS = 0, HX509_KEY_FORMAT_DER = 1, HX509_KEY_FORMAT_WIN_BACKUPKEY = 2 }; typedef uint32_t hx509_key_format_t; struct hx509_cert_attribute_data { heim_oid oid; heim_octet_string data; }; typedef enum { HX509_PROMPT_TYPE_PASSWORD = 0x1, /* password, hidden */ HX509_PROMPT_TYPE_QUESTION = 0x2, /* question, not hidden */ HX509_PROMPT_TYPE_INFO = 0x4 /* infomation, reply doesn't matter */ } hx509_prompt_type; typedef struct hx509_prompt { const char *prompt; hx509_prompt_type type; heim_octet_string reply; } hx509_prompt; typedef int (*hx509_prompter_fct)(void *, const hx509_prompt *); typedef struct hx509_octet_string_list { size_t len; heim_octet_string *val; } hx509_octet_string_list; typedef struct hx509_pem_header { struct hx509_pem_header *next; char *header; char *value; } hx509_pem_header; typedef int (*hx509_pem_read_func)(hx509_context, const char *, const hx509_pem_header *, const void *, size_t, void *ctx); /* * Options passed to hx509_query_match_option. */ typedef enum { HX509_QUERY_OPTION_PRIVATE_KEY = 1, HX509_QUERY_OPTION_KU_ENCIPHERMENT = 2, HX509_QUERY_OPTION_KU_DIGITALSIGNATURE = 3, HX509_QUERY_OPTION_KU_KEYCERTSIGN = 4, HX509_QUERY_OPTION_END = 0xffff } hx509_query_option; /* flags to hx509_certs_init */ #define HX509_CERTS_CREATE 0x01 #define HX509_CERTS_UNPROTECT_ALL 0x02 /* flags to hx509_set_error_string */ #define HX509_ERROR_APPEND 0x01 /* flags to hx509_cms_unenvelope */ #define HX509_CMS_UE_DONT_REQUIRE_KU_ENCIPHERMENT 0x01 #define HX509_CMS_UE_ALLOW_WEAK 0x02 /* flags to hx509_cms_envelope_1 */ #define HX509_CMS_EV_NO_KU_CHECK 0x01 #define HX509_CMS_EV_ALLOW_WEAK 0x02 #define HX509_CMS_EV_ID_NAME 0x04 /* flags to hx509_cms_verify_signed */ #define HX509_CMS_VS_ALLOW_DATA_OID_MISMATCH 0x01 #define HX509_CMS_VS_NO_KU_CHECK 0x02 #define HX509_CMS_VS_ALLOW_ZERO_SIGNER 0x04 #define HX509_CMS_VS_NO_VALIDATE 0x08 /* selectors passed to hx509_crypto_select and hx509_crypto_available */ #define HX509_SELECT_ALL 0 #define HX509_SELECT_DIGEST 1 #define HX509_SELECT_PUBLIC_SIG 2 #define HX509_SELECT_PUBLIC_ENC 3 #define HX509_SELECT_SECRET_ENC 4 /* flags to hx509_ca_tbs_set_template */ #define HX509_CA_TEMPLATE_SUBJECT 1 #define HX509_CA_TEMPLATE_SERIAL 2 #define HX509_CA_TEMPLATE_NOTBEFORE 4 #define HX509_CA_TEMPLATE_NOTAFTER 8 #define HX509_CA_TEMPLATE_SPKI 16 #define HX509_CA_TEMPLATE_KU 32 #define HX509_CA_TEMPLATE_EKU 64 /* flags hx509_cms_create_signed* */ #define HX509_CMS_SIGNATURE_DETACHED 0x01 #define HX509_CMS_SIGNATURE_ID_NAME 0x02 #define HX509_CMS_SIGNATURE_NO_SIGNER 0x04 #define HX509_CMS_SIGNATURE_LEAF_ONLY 0x08 #define HX509_CMS_SIGNATURE_NO_CERTS 0x10 /* hx509_verify_hostname nametype */ typedef enum { HX509_HN_HOSTNAME = 0, HX509_HN_DNSSRV } hx509_hostname_type; #include #include #endif /* HEIMDAL_HX509_H */ pykrb5-0.8.0/build_helpers/heimdal/include/hx509_err.h000066400000000000000000000062431505521762700225170ustar00rootroot00000000000000/* Generated from hx509_err.et */ /* $Id$ */ #ifndef __hx509_err_h__ #define __hx509_err_h__ struct et_list; void initialize_hx_error_table_r(struct et_list **); void initialize_hx_error_table(void); #define init_hx_err_tbl initialize_hx_error_table typedef enum hx_error_number{ HX509_BAD_TIMEFORMAT = 569856, HX509_EXTENSION_NOT_FOUND = 569857, HX509_NO_PATH = 569858, HX509_PARENT_NOT_CA = 569859, HX509_CA_PATH_TOO_DEEP = 569860, HX509_SIG_ALG_NO_SUPPORTED = 569861, HX509_SIG_ALG_DONT_MATCH_KEY_ALG = 569862, HX509_CERT_USED_BEFORE_TIME = 569863, HX509_CERT_USED_AFTER_TIME = 569864, HX509_PRIVATE_KEY_MISSING = 569865, HX509_ALG_NOT_SUPP = 569866, HX509_ISSUER_NOT_FOUND = 569867, HX509_VERIFY_CONSTRAINTS = 569868, HX509_RANGE = 569869, HX509_NAME_CONSTRAINT_ERROR = 569870, HX509_PATH_TOO_LONG = 569871, HX509_KU_CERT_MISSING = 569872, HX509_CERT_NOT_FOUND = 569873, HX509_UNKNOWN_LOCK_COMMAND = 569874, HX509_PARENT_IS_CA = 569875, HX509_EXTRA_DATA_AFTER_STRUCTURE = 569876, HX509_PROXY_CERT_INVALID = 569877, HX509_PROXY_CERT_NAME_WRONG = 569878, HX509_NAME_MALFORMED = 569879, HX509_CERTIFICATE_MALFORMED = 569880, HX509_CERTIFICATE_MISSING_EKU = 569881, HX509_PROXY_CERTIFICATE_NOT_CANONICALIZED = 569882, HX509_CMS_FAILED_CREATE_SIGATURE = 569888, HX509_CMS_MISSING_SIGNER_DATA = 569889, HX509_CMS_SIGNER_NOT_FOUND = 569890, HX509_CMS_NO_DATA_AVAILABLE = 569891, HX509_CMS_INVALID_DATA = 569892, HX509_CMS_PADDING_ERROR = 569893, HX509_CMS_NO_RECIPIENT_CERTIFICATE = 569894, HX509_CMS_DATA_OID_MISMATCH = 569895, HX509_CRYPTO_INTERNAL_ERROR = 569920, HX509_CRYPTO_EXTERNAL_ERROR = 569921, HX509_CRYPTO_SIGNATURE_MISSING = 569922, HX509_CRYPTO_BAD_SIGNATURE = 569923, HX509_CRYPTO_SIG_NO_CONF = 569924, HX509_CRYPTO_SIG_INVALID_FORMAT = 569925, HX509_CRYPTO_OID_MISMATCH = 569926, HX509_CRYPTO_NO_PROMPTER = 569927, HX509_CRYPTO_SIGNATURE_WITHOUT_SIGNER = 569928, HX509_CRYPTO_RSA_PUBLIC_ENCRYPT = 569929, HX509_CRYPTO_RSA_PRIVATE_ENCRYPT = 569930, HX509_CRYPTO_RSA_PUBLIC_DECRYPT = 569931, HX509_CRYPTO_RSA_PRIVATE_DECRYPT = 569932, HX509_CRYPTO_ALGORITHM_BEST_BEFORE = 569933, HX509_CRYPTO_KEY_FORMAT_UNSUPPORTED = 569934, HX509_CRL_USED_BEFORE_TIME = 569952, HX509_CRL_USED_AFTER_TIME = 569953, HX509_CRL_INVALID_FORMAT = 569954, HX509_CERT_REVOKED = 569955, HX509_REVOKE_STATUS_MISSING = 569956, HX509_CRL_UNKNOWN_EXTENSION = 569957, HX509_REVOKE_WRONG_DATA = 569958, HX509_REVOKE_NOT_SAME_PARENT = 569959, HX509_CERT_NOT_IN_OCSP = 569960, HX509_LOCAL_ATTRIBUTE_MISSING = 569964, HX509_PARSING_KEY_FAILED = 569965, HX509_UNSUPPORTED_OPERATION = 569966, HX509_UNIMPLEMENTED_OPERATION = 569967, HX509_PARSING_NAME_FAILED = 569968, HX509_PKCS11_NO_SLOT = 569984, HX509_PKCS11_NO_TOKEN = 569985, HX509_PKCS11_NO_MECH = 569986, HX509_PKCS11_TOKEN_CONFUSED = 569987, HX509_PKCS11_OPEN_SESSION = 569988, HX509_PKCS11_LOGIN = 569989, HX509_PKCS11_LOAD = 569990, HX509_PKCS11_PIN_INCORRECT = 569991, HX509_PKCS11_PIN_LOCKED = 569992, HX509_PKCS11_PIN_NOT_INITIALIZED = 569993, HX509_PKCS11_PIN_EXPIRED = 569994 } hx_error_number; #define ERROR_TABLE_BASE_hx 569856 #define COM_ERR_BINDDOMAIN_hx "heim_com_err569856" #endif /* __hx509_err_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/k524_err.h000066400000000000000000000012631505521762700223240ustar00rootroot00000000000000/* Generated from k524_err.et */ /* $Id$ */ #ifndef __k524_err_h__ #define __k524_err_h__ struct et_list; void initialize_k524_error_table_r(struct et_list **); void initialize_k524_error_table(void); #define init_k524_err_tbl initialize_k524_error_table typedef enum k524_error_number{ KRB524_BADKEY = -1750206208, KRB524_BADADDR = -1750206207, KRB524_BADPRINC = -1750206206, KRB524_BADREALM = -1750206205, KRB524_V4ERR = -1750206204, KRB524_ENCFULL = -1750206203, KRB524_DECEMPTY = -1750206202, KRB524_NOTRESP = -1750206201 } k524_error_number; #define ERROR_TABLE_BASE_k524 -1750206208 #define COM_ERR_BINDDOMAIN_k524 "heim_com_err-1750206208" #endif /* __k524_err_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/kadm5/000077500000000000000000000000001505521762700216155ustar00rootroot00000000000000pykrb5-0.8.0/build_helpers/heimdal/include/kadm5/admin.h000066400000000000000000000172101505521762700230570ustar00rootroot00000000000000/* * Copyright (c) 1997-2000 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef __KADM5_ADMIN_H__ #define __KADM5_ADMIN_H__ #define KADM5_API_VERSION_1 1 #define KADM5_API_VERSION_2 2 #ifndef USE_KADM5_API_VERSION #define USE_KADM5_API_VERSION KADM5_API_VERSION_2 #endif #if USE_KADM5_API_VERSION != KADM5_API_VERSION_2 #error No support for API versions other than 2 #endif #define KADM5_STRUCT_VERSION 0 /* For kadm5_log_get_version_fd() */ #define LOG_VERSION_LAST -1 #define LOG_VERSION_FIRST 1 #define LOG_VERSION_UBER 0 #include #define KRB5_KDB_DISALLOW_POSTDATED 0x00000001 #define KRB5_KDB_DISALLOW_FORWARDABLE 0x00000002 #define KRB5_KDB_DISALLOW_TGT_BASED 0x00000004 #define KRB5_KDB_DISALLOW_RENEWABLE 0x00000008 #define KRB5_KDB_DISALLOW_PROXIABLE 0x00000010 #define KRB5_KDB_DISALLOW_DUP_SKEY 0x00000020 #define KRB5_KDB_DISALLOW_ALL_TIX 0x00000040 #define KRB5_KDB_REQUIRES_PRE_AUTH 0x00000080 #define KRB5_KDB_REQUIRES_HW_AUTH 0x00000100 #define KRB5_KDB_REQUIRES_PWCHANGE 0x00000200 #define KRB5_KDB_DISALLOW_SVR 0x00001000 #define KRB5_KDB_PWCHANGE_SERVICE 0x00002000 #define KRB5_KDB_SUPPORT_DESMD5 0x00004000 #define KRB5_KDB_NEW_PRINC 0x00008000 #define KRB5_KDB_OK_AS_DELEGATE 0x00010000 #define KRB5_KDB_TRUSTED_FOR_DELEGATION 0x00020000 #define KRB5_KDB_ALLOW_KERBEROS4 0x00040000 #define KRB5_KDB_ALLOW_DIGEST 0x00080000 #define KADM5_PRINCIPAL 0x000001 #define KADM5_PRINC_EXPIRE_TIME 0x000002 #define KADM5_PW_EXPIRATION 0x000004 #define KADM5_LAST_PWD_CHANGE 0x000008 #define KADM5_ATTRIBUTES 0x000010 #define KADM5_MAX_LIFE 0x000020 #define KADM5_MOD_TIME 0x000040 #define KADM5_MOD_NAME 0x000080 #define KADM5_KVNO 0x000100 #define KADM5_MKVNO 0x000200 #define KADM5_AUX_ATTRIBUTES 0x000400 #define KADM5_POLICY 0x000800 #define KADM5_POLICY_CLR 0x001000 #define KADM5_MAX_RLIFE 0x002000 #define KADM5_LAST_SUCCESS 0x004000 #define KADM5_LAST_FAILED 0x008000 #define KADM5_FAIL_AUTH_COUNT 0x010000 #define KADM5_KEY_DATA 0x020000 #define KADM5_TL_DATA 0x040000 #define KADM5_PRINCIPAL_NORMAL_MASK (~(KADM5_KEY_DATA | KADM5_TL_DATA)) #define KADM5_PW_MAX_LIFE 0x004000 #define KADM5_PW_MIN_LIFE 0x008000 #define KADM5_PW_MIN_LENGTH 0x010000 #define KADM5_PW_MIN_CLASSES 0x020000 #define KADM5_PW_HISTORY_NUM 0x040000 #define KADM5_REF_COUNT 0x080000 #define KADM5_POLICY_NORMAL_MASK (~0) #define KADM5_ADMIN_SERVICE "kadmin/admin" #define KADM5_HIST_PRINCIPAL "kadmin/history" #define KADM5_CHANGEPW_SERVICE "kadmin/changepw" typedef struct { int16_t key_data_ver; /* Version */ int16_t key_data_kvno; /* Key Version */ int16_t key_data_type[2]; /* Array of types */ int16_t key_data_length[2]; /* Array of lengths */ void* key_data_contents[2];/* Array of pointers */ } krb5_key_data; typedef struct _krb5_keysalt { int16_t type; krb5_data data; /* Length, data */ } krb5_keysalt; typedef struct _krb5_tl_data { struct _krb5_tl_data* tl_data_next; int16_t tl_data_type; int16_t tl_data_length; void* tl_data_contents; } krb5_tl_data; #define KRB5_TL_LAST_PWD_CHANGE 0x0001 #define KRB5_TL_MOD_PRINC 0x0002 #define KRB5_TL_KADM_DATA 0x0003 #define KRB5_TL_KADM5_E_DATA 0x0004 #define KRB5_TL_RB1_CHALLENGE 0x0005 #define KRB5_TL_SECURID_STATE 0x0006 #define KRB5_TL_PASSWORD 0x0007 #define KRB5_TL_EXTENSION 0x0008 #define KRB5_TL_PKINIT_ACL 0x0009 #define KRB5_TL_ALIASES 0x000a #define KRB5_TL_HIST_KVNO_DIFF_CLNT 0x000b #define KRB5_TL_HIST_KVNO_DIFF_SVC 0x000c typedef struct _kadm5_principal_ent_t { krb5_principal principal; krb5_timestamp princ_expire_time; krb5_timestamp last_pwd_change; krb5_timestamp pw_expiration; krb5_deltat max_life; krb5_principal mod_name; krb5_timestamp mod_date; krb5_flags attributes; krb5_kvno kvno; krb5_kvno mkvno; char * policy; uint32_t aux_attributes; krb5_deltat max_renewable_life; krb5_timestamp last_success; krb5_timestamp last_failed; krb5_kvno fail_auth_count; int16_t n_key_data; int16_t n_tl_data; krb5_tl_data *tl_data; krb5_key_data *key_data; } kadm5_principal_ent_rec, *kadm5_principal_ent_t; typedef struct _kadm5_policy_ent_t { char *policy; uint32_t pw_min_life; uint32_t pw_max_life; uint32_t pw_min_length; uint32_t pw_min_classes; uint32_t pw_history_num; uint32_t policy_refcnt; } kadm5_policy_ent_rec, *kadm5_policy_ent_t; #define KADM5_CONFIG_REALM (1 << 0) #define KADM5_CONFIG_PROFILE (1 << 1) #define KADM5_CONFIG_KADMIND_PORT (1 << 2) #define KADM5_CONFIG_ADMIN_SERVER (1 << 3) #define KADM5_CONFIG_DBNAME (1 << 4) #define KADM5_CONFIG_ADBNAME (1 << 5) #define KADM5_CONFIG_ADB_LOCKFILE (1 << 6) #define KADM5_CONFIG_ACL_FILE (1 << 7) #define KADM5_CONFIG_DICT_FILE (1 << 8) #define KADM5_CONFIG_ADMIN_KEYTAB (1 << 9) #define KADM5_CONFIG_MKEY_FROM_KEYBOARD (1 << 10) #define KADM5_CONFIG_STASH_FILE (1 << 11) #define KADM5_CONFIG_MKEY_NAME (1 << 12) #define KADM5_CONFIG_ENCTYPE (1 << 13) #define KADM5_CONFIG_MAX_LIFE (1 << 14) #define KADM5_CONFIG_MAX_RLIFE (1 << 15) #define KADM5_CONFIG_EXPIRATION (1 << 16) #define KADM5_CONFIG_FLAGS (1 << 17) #define KADM5_CONFIG_ENCTYPES (1 << 18) #define KADM5_PRIV_GET (1 << 0) #define KADM5_PRIV_ADD (1 << 1) #define KADM5_PRIV_MODIFY (1 << 2) #define KADM5_PRIV_DELETE (1 << 3) #define KADM5_PRIV_LIST (1 << 4) #define KADM5_PRIV_CPW (1 << 5) #define KADM5_PRIV_GET_KEYS (1 << 6) /* Note: KADM5_PRIV_GET_KEYS not included */ #define KADM5_PRIV_ALL (KADM5_PRIV_GET | KADM5_PRIV_ADD | KADM5_PRIV_MODIFY | KADM5_PRIV_DELETE | KADM5_PRIV_LIST | KADM5_PRIV_CPW) #define KADM5_BOGUS_KEY_DATA "\xe5\xe5\xe5\xe5" typedef struct _kadm5_config_params { uint32_t mask; /* Client and server fields */ char *realm; int kadmind_port; /* client fields */ char *admin_server; /* server fields */ char *dbname; char *acl_file; /* server library (database) fields */ char *stash_file; } kadm5_config_params; typedef krb5_error_code kadm5_ret_t; #include "kadm5-protos.h" #endif /* __KADM5_ADMIN_H__ */ pykrb5-0.8.0/build_helpers/heimdal/include/kadm5/kadm5-private.h000066400000000000000000000304041505521762700244400ustar00rootroot00000000000000/* This is a generated file */ #ifndef __kadm5_private_h__ #define __kadm5_private_h__ #include kadm5_ret_t _kadm5_acl_check_permission ( kadm5_server_context */*context*/, unsigned /*op*/, krb5_const_principal /*princ*/); kadm5_ret_t _kadm5_acl_init (kadm5_server_context */*context*/); kadm5_ret_t _kadm5_bump_pw_expire ( kadm5_server_context */*context*/, hdb_entry */*ent*/); krb5_error_code _kadm5_c_get_cred_cache ( krb5_context /*context*/, const char */*client_name*/, const char */*server_name*/, const char */*password*/, krb5_prompter_fct /*prompter*/, const char */*keytab*/, krb5_ccache /*ccache*/, krb5_ccache */*ret_cache*/); kadm5_ret_t _kadm5_c_init_context ( kadm5_client_context **/*ctx*/, kadm5_config_params */*params*/, krb5_context /*context*/); kadm5_ret_t _kadm5_client_recv ( kadm5_client_context */*context*/, krb5_data */*reply*/); kadm5_ret_t _kadm5_client_send ( kadm5_client_context */*context*/, krb5_storage */*sp*/); kadm5_ret_t _kadm5_connect (void */*handle*/); kadm5_ret_t _kadm5_error_code (kadm5_ret_t /*code*/); int _kadm5_exists_keys_hist ( Key */*keys1*/, int /*len1*/, HDB_Ext_KeySet */*hist_keys*/); void _kadm5_free_keys ( krb5_context /*context*/, int /*len*/, Key */*keys*/); void _kadm5_init_keys ( Key */*keys*/, int /*len*/); kadm5_ret_t _kadm5_marshal_params ( krb5_context /*context*/, kadm5_config_params */*params*/, krb5_data */*out*/); kadm5_ret_t _kadm5_privs_to_string ( uint32_t /*privs*/, char */*string*/, size_t /*len*/); HDB * _kadm5_s_get_db (void */*server_handle*/); kadm5_ret_t _kadm5_s_init_context ( kadm5_server_context **/*ctx*/, kadm5_config_params */*params*/, krb5_context /*context*/); kadm5_ret_t _kadm5_set_keys ( kadm5_server_context */*context*/, hdb_entry */*ent*/, int /*n_ks_tuple*/, krb5_key_salt_tuple */*ks_tuple*/, const char */*password*/); kadm5_ret_t _kadm5_set_keys2 ( kadm5_server_context */*context*/, hdb_entry */*ent*/, int16_t /*n_key_data*/, krb5_key_data */*key_data*/); kadm5_ret_t _kadm5_set_keys3 ( kadm5_server_context */*context*/, hdb_entry */*ent*/, int /*n_keys*/, krb5_keyblock */*keyblocks*/); kadm5_ret_t _kadm5_set_keys_randomly ( kadm5_server_context */*context*/, hdb_entry */*ent*/, int /*n_ks_tuple*/, krb5_key_salt_tuple */*ks_tuple*/, krb5_keyblock **/*new_keys*/, int */*n_keys*/); kadm5_ret_t _kadm5_set_modifier ( kadm5_server_context */*context*/, hdb_entry */*ent*/); kadm5_ret_t _kadm5_setup_entry ( kadm5_server_context */*context*/, hdb_entry_ex */*ent*/, uint32_t /*mask*/, kadm5_principal_ent_t /*princ*/, uint32_t /*princ_mask*/, kadm5_principal_ent_t /*def*/, uint32_t /*def_mask*/); kadm5_ret_t _kadm5_string_to_privs ( const char */*s*/, uint32_t* /*privs*/); kadm5_ret_t _kadm5_unmarshal_params ( krb5_context /*context*/, krb5_data */*in*/, kadm5_config_params */*params*/); kadm5_ret_t kadm5_c_chpass_principal ( void */*server_handle*/, krb5_principal /*princ*/, int /*keepold*/, int /*n_ks_tuple*/, krb5_key_salt_tuple */*ks_tuple*/, const char */*password*/); kadm5_ret_t kadm5_c_chpass_principal_with_key ( void */*server_handle*/, krb5_principal /*princ*/, int /*keepold*/, int /*n_key_data*/, krb5_key_data */*key_data*/); kadm5_ret_t kadm5_c_create_principal ( void */*server_handle*/, kadm5_principal_ent_t /*princ*/, uint32_t /*mask*/, int /*n_ks_tuple*/, krb5_key_salt_tuple */*ks_tuple*/, const char */*password*/); kadm5_ret_t kadm5_c_delete_principal ( void */*server_handle*/, krb5_principal /*princ*/); kadm5_ret_t kadm5_c_destroy (void */*server_handle*/); kadm5_ret_t kadm5_c_flush (void */*server_handle*/); kadm5_ret_t kadm5_c_get_principal ( void */*server_handle*/, krb5_principal /*princ*/, kadm5_principal_ent_t /*out*/, uint32_t /*mask*/); kadm5_ret_t kadm5_c_get_principals ( void */*server_handle*/, const char */*expression*/, char ***/*princs*/, int */*count*/); kadm5_ret_t kadm5_c_get_privs ( void */*server_handle*/, uint32_t */*privs*/); kadm5_ret_t kadm5_c_init_with_creds ( const char */*client_name*/, krb5_ccache /*ccache*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); kadm5_ret_t kadm5_c_init_with_creds_ctx ( krb5_context /*context*/, const char */*client_name*/, krb5_ccache /*ccache*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); kadm5_ret_t kadm5_c_init_with_password ( const char */*client_name*/, const char */*password*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); kadm5_ret_t kadm5_c_init_with_password_ctx ( krb5_context /*context*/, const char */*client_name*/, const char */*password*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); kadm5_ret_t kadm5_c_init_with_skey ( const char */*client_name*/, const char */*keytab*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); kadm5_ret_t kadm5_c_init_with_skey_ctx ( krb5_context /*context*/, const char */*client_name*/, const char */*keytab*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); kadm5_ret_t kadm5_c_modify_principal ( void */*server_handle*/, kadm5_principal_ent_t /*princ*/, uint32_t /*mask*/); kadm5_ret_t kadm5_c_randkey_principal ( void */*server_handle*/, krb5_principal /*princ*/, krb5_boolean /*keepold*/, int /*n_ks_tuple*/, krb5_key_salt_tuple */*ks_tuple*/, krb5_keyblock **/*new_keys*/, int */*n_keys*/); kadm5_ret_t kadm5_c_rename_principal ( void */*server_handle*/, krb5_principal /*source*/, krb5_principal /*target*/); kadm5_ret_t kadm5_log_create ( kadm5_server_context */*context*/, hdb_entry */*entry*/); kadm5_ret_t kadm5_log_delete ( kadm5_server_context */*context*/, krb5_principal /*princ*/); kadm5_ret_t kadm5_log_end (kadm5_server_context */*server_context*/); kadm5_ret_t kadm5_log_foreach ( kadm5_server_context */*context*/, enum kadm_iter_opts /*iter_opts*/, off_t */*off_lastp*/, kadm5_ret_t (*/*func*/)(kadm5_server_context *server_context, uint32_t ver, time_t timestamp, enum kadm_ops op, uint32_t len, krb5_storage *sp, void *ctx), void */*ctx*/); kadm5_ret_t kadm5_log_get_version ( kadm5_server_context */*server_context*/, uint32_t */*ver*/); kadm5_ret_t kadm5_log_get_version_fd ( kadm5_server_context */*server_context*/, int /*fd*/, int /*which*/, uint32_t */*ver*/, uint32_t */*tstamp*/); krb5_storage * kadm5_log_goto_end ( kadm5_server_context */*server_context*/, int /*fd*/); kadm5_ret_t kadm5_log_init (kadm5_server_context */*server_context*/); kadm5_ret_t kadm5_log_init_nb (kadm5_server_context */*server_context*/); kadm5_ret_t kadm5_log_init_nolock (kadm5_server_context */*server_context*/); kadm5_ret_t kadm5_log_init_sharedlock ( kadm5_server_context */*server_context*/, int /*lock_flags*/); kadm5_ret_t kadm5_log_modify ( kadm5_server_context */*context*/, hdb_entry */*entry*/, uint32_t /*mask*/); kadm5_ret_t kadm5_log_nop ( kadm5_server_context */*context*/, enum kadm_nop_type /*nop_type*/); kadm5_ret_t kadm5_log_previous ( krb5_context /*context*/, krb5_storage */*sp*/, uint32_t */*verp*/, time_t */*tstampp*/, enum kadm_ops */*opp*/, uint32_t */*lenp*/); kadm5_ret_t kadm5_log_recover ( kadm5_server_context */*context*/, enum kadm_recover_mode /*mode*/); kadm5_ret_t kadm5_log_reinit ( kadm5_server_context */*server_context*/, uint32_t /*vno*/); kadm5_ret_t kadm5_log_rename ( kadm5_server_context */*context*/, krb5_principal /*source*/, hdb_entry */*entry*/); kadm5_ret_t kadm5_log_replay ( kadm5_server_context */*context*/, enum kadm_ops /*op*/, uint32_t /*ver*/, uint32_t /*len*/, krb5_storage */*sp*/); kadm5_ret_t kadm5_log_set_version ( kadm5_server_context */*context*/, uint32_t /*vno*/); void kadm5_log_signal_master (kadm5_server_context */*context*/); const char * kadm5_log_signal_socket (krb5_context /*context*/); kadm5_ret_t kadm5_log_signal_socket_info ( krb5_context /*context*/, int /*server_end*/, struct addrinfo **/*ret_addrs*/); kadm5_ret_t kadm5_log_truncate ( kadm5_server_context */*context*/, size_t /*keep*/, size_t /*maxbytes*/); kadm5_ret_t kadm5_s_chpass_principal ( void */*server_handle*/, krb5_principal /*princ*/, int /*keepold*/, int /*n_ks_tuple*/, krb5_key_salt_tuple */*ks_tuple*/, const char */*password*/); kadm5_ret_t kadm5_s_chpass_principal_cond ( void */*server_handle*/, krb5_principal /*princ*/, int /*keepold*/, const char */*password*/); kadm5_ret_t kadm5_s_chpass_principal_with_key ( void */*server_handle*/, krb5_principal /*princ*/, int /*keepold*/, int /*n_key_data*/, krb5_key_data */*key_data*/); kadm5_ret_t kadm5_s_create_principal ( void */*server_handle*/, kadm5_principal_ent_t /*princ*/, uint32_t /*mask*/, int /*n_ks_tuple*/, krb5_key_salt_tuple */*ks_tuple*/, const char */*password*/); kadm5_ret_t kadm5_s_create_principal_with_key ( void */*server_handle*/, kadm5_principal_ent_t /*princ*/, uint32_t /*mask*/); kadm5_ret_t kadm5_s_delete_principal ( void */*server_handle*/, krb5_principal /*princ*/); kadm5_ret_t kadm5_s_destroy (void */*server_handle*/); kadm5_ret_t kadm5_s_flush (void */*server_handle*/); kadm5_ret_t kadm5_s_get_principal ( void */*server_handle*/, krb5_principal /*princ*/, kadm5_principal_ent_t /*out*/, uint32_t /*mask*/); kadm5_ret_t kadm5_s_get_principals ( void */*server_handle*/, const char */*expression*/, char ***/*princs*/, int */*count*/); kadm5_ret_t kadm5_s_get_privs ( void */*server_handle*/, uint32_t */*privs*/); kadm5_ret_t kadm5_s_init_with_creds ( const char */*client_name*/, krb5_ccache /*ccache*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); kadm5_ret_t kadm5_s_init_with_creds_ctx ( krb5_context /*context*/, const char */*client_name*/, krb5_ccache /*ccache*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); kadm5_ret_t kadm5_s_init_with_password ( const char */*client_name*/, const char */*password*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); kadm5_ret_t kadm5_s_init_with_password_ctx ( krb5_context /*context*/, const char */*client_name*/, const char */*password*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); kadm5_ret_t kadm5_s_init_with_skey ( const char */*client_name*/, const char */*keytab*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); kadm5_ret_t kadm5_s_init_with_skey_ctx ( krb5_context /*context*/, const char */*client_name*/, const char */*keytab*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); kadm5_ret_t kadm5_s_modify_principal ( void */*server_handle*/, kadm5_principal_ent_t /*princ*/, uint32_t /*mask*/); kadm5_ret_t kadm5_s_randkey_principal ( void */*server_handle*/, krb5_principal /*princ*/, krb5_boolean /*keepold*/, int /*n_ks_tuple*/, krb5_key_salt_tuple */*ks_tuple*/, krb5_keyblock **/*new_keys*/, int */*n_keys*/); kadm5_ret_t kadm5_s_rename_principal ( void */*server_handle*/, krb5_principal /*source*/, krb5_principal /*target*/); kadm5_ret_t kadm5_s_setkey_principal_3 ( void */*server_handle*/, krb5_principal /*princ*/, krb5_boolean /*keepold*/, int /*n_ks_tuple*/, krb5_key_salt_tuple */*ks_tuple*/, krb5_keyblock */*keyblocks*/, int /*n_keys*/); #endif /* __kadm5_private_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/kadm5/kadm5-protos.h000066400000000000000000000210071505521762700243130ustar00rootroot00000000000000/* This is a generated file */ #ifndef __kadm5_protos_h__ #define __kadm5_protos_h__ #ifndef DOXY #include #ifdef __cplusplus extern "C" { #endif kadm5_ret_t kadm5_ad_init_with_password ( const char */*client_name*/, const char */*password*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); kadm5_ret_t kadm5_ad_init_with_password_ctx ( krb5_context /*context*/, const char */*client_name*/, const char */*password*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); krb5_error_code kadm5_add_passwd_quality_verifier ( krb5_context /*context*/, const char */*check_library*/); int kadm5_all_keys_are_bogus ( size_t /*n_keys*/, krb5_key_data */*keys*/); const char * kadm5_check_password_quality ( krb5_context /*context*/, krb5_principal /*principal*/, krb5_data */*pwd_data*/); kadm5_ret_t kadm5_chpass_principal ( void */*server_handle*/, krb5_principal /*princ*/, const char */*password*/); kadm5_ret_t kadm5_chpass_principal_3 ( void */*server_handle*/, krb5_principal /*princ*/, krb5_boolean /*keepold*/, int /*n_ks_tuple*/, krb5_key_salt_tuple */*ks_tuple*/, const char */*password*/); kadm5_ret_t kadm5_chpass_principal_with_key ( void */*server_handle*/, krb5_principal /*princ*/, int /*n_key_data*/, krb5_key_data */*key_data*/); kadm5_ret_t kadm5_chpass_principal_with_key_3 ( void */*server_handle*/, krb5_principal /*princ*/, int /*keepold*/, int /*n_key_data*/, krb5_key_data */*key_data*/); kadm5_ret_t kadm5_create_policy ( void */*server_handle*/, kadm5_policy_ent_t /*policy*/, long /*mask*/); kadm5_ret_t kadm5_create_principal ( void */*server_handle*/, kadm5_principal_ent_t /*princ*/, uint32_t /*mask*/, const char */*password*/); kadm5_ret_t kadm5_create_principal_3 ( void */*server_handle*/, kadm5_principal_ent_t /*princ*/, uint32_t /*mask*/, int /*n_ks_tuple*/, krb5_key_salt_tuple */*ks_tuple*/, char */*password*/); /** * Extract decrypted keys from kadm5_principal_ent_t object. Mostly a * no-op for Heimdal because we fetch the entry with decrypted keys. * Sadly this is not fully a no-op, as we have to allocate a copy. * * @server_handle is the kadm5 handle * @entry is the HDB entry for the principal in question * @ktype is the enctype to get a key for, or -1 to get the first one * @stype is the salttype to get a key for, or -1 to get the first match * @kvno is the kvno to search for, or -1 to get the first match (highest kvno) * @keyblock is where the key will be placed * @keysalt, if not NULL, is where the salt will be placed * @kvnop, if not NULL, is where the selected kvno will be placed */ kadm5_ret_t kadm5_decrypt_key ( void */*server_handle*/, kadm5_principal_ent_t /*entry*/, int32_t /*ktype*/, int32_t /*stype*/, int32_t /*kvno*/, krb5_keyblock */*keyblock*/, krb5_keysalt */*keysalt*/, int */*kvnop*/); kadm5_ret_t kadm5_delete_policy ( void */*server_handle*/, char */*name*/); kadm5_ret_t kadm5_delete_principal ( void */*server_handle*/, krb5_principal /*princ*/); kadm5_ret_t kadm5_destroy (void */*server_handle*/); kadm5_ret_t kadm5_flush (void */*server_handle*/); void kadm5_free_key_data ( void */*server_handle*/, int16_t */*n_key_data*/, krb5_key_data */*key_data*/); void kadm5_free_name_list ( void */*server_handle*/, char **/*names*/, int */*count*/); kadm5_ret_t kadm5_free_policy_ent (kadm5_policy_ent_t /*ent*/); void kadm5_free_principal_ent ( void */*server_handle*/, kadm5_principal_ent_t /*princ*/); kadm5_ret_t kadm5_get_policies ( void */*server_handle*/, char */*exp*/, char ***/*pols*/, int */*count*/); kadm5_ret_t kadm5_get_policy ( void */*server_handle*/, char */*policy*/, kadm5_policy_ent_t /*ent*/); kadm5_ret_t kadm5_get_principal ( void */*server_handle*/, krb5_principal /*princ*/, kadm5_principal_ent_t /*out*/, uint32_t /*mask*/); kadm5_ret_t kadm5_get_principals ( void */*server_handle*/, const char */*expression*/, char ***/*princs*/, int */*count*/); kadm5_ret_t kadm5_get_privs ( void */*server_handle*/, uint32_t */*privs*/); kadm5_ret_t kadm5_init_with_creds ( const char */*client_name*/, krb5_ccache /*ccache*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); kadm5_ret_t kadm5_init_with_creds_ctx ( krb5_context /*context*/, const char */*client_name*/, krb5_ccache /*ccache*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); kadm5_ret_t kadm5_init_with_password ( const char */*client_name*/, const char */*password*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); kadm5_ret_t kadm5_init_with_password_ctx ( krb5_context /*context*/, const char */*client_name*/, const char */*password*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); kadm5_ret_t kadm5_init_with_skey ( const char */*client_name*/, const char */*keytab*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); kadm5_ret_t kadm5_init_with_skey_ctx ( krb5_context /*context*/, const char */*client_name*/, const char */*keytab*/, const char */*service_name*/, kadm5_config_params */*realm_params*/, unsigned long /*struct_version*/, unsigned long /*api_version*/, void **/*server_handle*/); kadm5_ret_t kadm5_lock (void */*server_handle*/); kadm5_ret_t kadm5_modify_policy ( void */*server_handle*/, kadm5_policy_ent_t /*policy*/, uint32_t /*mask*/); kadm5_ret_t kadm5_modify_principal ( void */*server_handle*/, kadm5_principal_ent_t /*princ*/, uint32_t /*mask*/); kadm5_ret_t kadm5_randkey_principal ( void */*server_handle*/, krb5_principal /*princ*/, krb5_keyblock **/*new_keys*/, int */*n_keys*/); kadm5_ret_t kadm5_randkey_principal_3 ( void */*server_handle*/, krb5_principal /*princ*/, krb5_boolean /*keepold*/, int /*n_ks_tuple*/, krb5_key_salt_tuple */*ks_tuple*/, krb5_keyblock **/*new_keys*/, int */*n_keys*/); kadm5_ret_t kadm5_rename_principal ( void */*server_handle*/, krb5_principal /*source*/, krb5_principal /*target*/); kadm5_ret_t kadm5_ret_key_data ( krb5_storage */*sp*/, krb5_key_data */*key*/); kadm5_ret_t kadm5_ret_principal_ent ( krb5_storage */*sp*/, kadm5_principal_ent_t /*princ*/); kadm5_ret_t kadm5_ret_principal_ent_mask ( krb5_storage */*sp*/, kadm5_principal_ent_t /*princ*/, uint32_t */*mask*/); kadm5_ret_t kadm5_ret_tl_data ( krb5_storage */*sp*/, krb5_tl_data */*tl*/); /** * This function is allows the caller to set new keys for a principal. * This is a trivial wrapper around kadm5_setkey_principal_3(). */ kadm5_ret_t kadm5_setkey_principal ( void */*server_handle*/, krb5_principal /*princ*/, krb5_keyblock */*new_keys*/, int /*n_keys*/); /** * This function is allows the caller to set new keys for a principal. * This is a simple wrapper around kadm5_get_principal() and * kadm5_modify_principal(). */ kadm5_ret_t kadm5_setkey_principal_3 ( void */*server_handle*/, krb5_principal /*princ*/, krb5_boolean /*keepold*/, int /*n_ks_tuple*/, krb5_key_salt_tuple */*ks_tuple*/, krb5_keyblock */*keyblocks*/, int /*n_keys*/); void kadm5_setup_passwd_quality_check ( krb5_context /*context*/, const char */*check_library*/, const char */*check_function*/); int kadm5_some_keys_are_bogus ( size_t /*n_keys*/, krb5_key_data */*keys*/); kadm5_ret_t kadm5_store_fake_key_data ( krb5_storage */*sp*/, krb5_key_data */*key*/); kadm5_ret_t kadm5_store_key_data ( krb5_storage */*sp*/, krb5_key_data */*key*/); kadm5_ret_t kadm5_store_principal_ent ( krb5_storage */*sp*/, kadm5_principal_ent_t /*princ*/); kadm5_ret_t kadm5_store_principal_ent_mask ( krb5_storage */*sp*/, kadm5_principal_ent_t /*princ*/, uint32_t /*mask*/); kadm5_ret_t kadm5_store_principal_ent_nokeys ( krb5_storage */*sp*/, kadm5_principal_ent_t /*princ*/); kadm5_ret_t kadm5_store_tl_data ( krb5_storage */*sp*/, krb5_tl_data */*tl*/); kadm5_ret_t kadm5_unlock (void */*server_handle*/); #ifdef __cplusplus } #endif #endif /* DOXY */ #endif /* __kadm5_protos_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/kadm5/kadm5-pwcheck.h000066400000000000000000000047501505521762700244170ustar00rootroot00000000000000/* * Copyright (c) 2004 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef KADM5_PWCHECK_H #define KADM5_PWCHECK_H 1 #define KADM5_PASSWD_VERSION_V0 0 #define KADM5_PASSWD_VERSION_V1 1 typedef const char* (*kadm5_passwd_quality_check_func_v0)(krb5_context, krb5_principal, krb5_data*); /* * The 4th argument, is a tuning parameter for the quality check * function, the lib/caller will providing it for the password quality * module. */ typedef int (*kadm5_passwd_quality_check_func)(krb5_context context, krb5_principal principal, krb5_data *password, const char *tuning, char *message, size_t length); struct kadm5_pw_policy_check_func { const char *name; kadm5_passwd_quality_check_func func; }; struct kadm5_pw_policy_verifier { const char *name; int version; const char *vendor; const struct kadm5_pw_policy_check_func *funcs; }; #endif /* KADM5_PWCHECK_H */ pykrb5-0.8.0/build_helpers/heimdal/include/kadm5/kadm5_err.h000066400000000000000000000045421505521762700236440ustar00rootroot00000000000000/* Generated from kadm5_err.et */ /* $Id$ */ #ifndef __kadm5_err_h__ #define __kadm5_err_h__ struct et_list; void initialize_kadm5_error_table_r(struct et_list **); void initialize_kadm5_error_table(void); #define init_kadm5_err_tbl initialize_kadm5_error_table typedef enum kadm5_error_number{ KADM5_FAILURE = 43787520, KADM5_AUTH_GET = 43787521, KADM5_AUTH_ADD = 43787522, KADM5_AUTH_MODIFY = 43787523, KADM5_AUTH_DELETE = 43787524, KADM5_AUTH_INSUFFICIENT = 43787525, KADM5_BAD_DB = 43787526, KADM5_DUP = 43787527, KADM5_RPC_ERROR = 43787528, KADM5_NO_SRV = 43787529, KADM5_BAD_HIST_KEY = 43787530, KADM5_NOT_INIT = 43787531, KADM5_UNK_PRINC = 43787532, KADM5_UNK_POLICY = 43787533, KADM5_BAD_MASK = 43787534, KADM5_BAD_CLASS = 43787535, KADM5_BAD_LENGTH = 43787536, KADM5_BAD_POLICY = 43787537, KADM5_BAD_PRINCIPAL = 43787538, KADM5_BAD_AUX_ATTR = 43787539, KADM5_BAD_HISTORY = 43787540, KADM5_BAD_MIN_PASS_LIFE = 43787541, KADM5_PASS_Q_TOOSHORT = 43787542, KADM5_PASS_Q_CLASS = 43787543, KADM5_PASS_Q_DICT = 43787544, KADM5_PASS_REUSE = 43787545, KADM5_PASS_TOOSOON = 43787546, KADM5_POLICY_REF = 43787547, KADM5_INIT = 43787548, KADM5_BAD_PASSWORD = 43787549, KADM5_PROTECT_PRINCIPAL = 43787550, KADM5_BAD_SERVER_HANDLE = 43787551, KADM5_BAD_STRUCT_VERSION = 43787552, KADM5_OLD_STRUCT_VERSION = 43787553, KADM5_NEW_STRUCT_VERSION = 43787554, KADM5_BAD_API_VERSION = 43787555, KADM5_OLD_LIB_API_VERSION = 43787556, KADM5_OLD_SERVER_API_VERSION = 43787557, KADM5_NEW_LIB_API_VERSION = 43787558, KADM5_NEW_SERVER_API_VERSION = 43787559, KADM5_SECURE_PRINC_MISSING = 43787560, KADM5_NO_RENAME_SALT = 43787561, KADM5_BAD_CLIENT_PARAMS = 43787562, KADM5_BAD_SERVER_PARAMS = 43787563, KADM5_AUTH_LIST = 43787564, KADM5_AUTH_CHANGEPW = 43787565, KADM5_BAD_TL_TYPE = 43787566, KADM5_MISSING_CONF_PARAMS = 43787567, KADM5_BAD_SERVER_NAME = 43787568, KADM5_KS_TUPLE_NOSUPP = 43787569, KADM5_SETKEY3_ETYPE_MISMATCH = 43787570, KADM5_DECRYPT_USAGE_NOSUPP = 43787571, KADM5_POLICY_OP_NOSUPP = 43787572, KADM5_KEEPOLD_NOSUPP = 43787573, KADM5_AUTH_GET_KEYS = 43787574, KADM5_ALREADY_LOCKED = 43787575, KADM5_NOT_LOCKED = 43787576, KADM5_LOG_CORRUPT = 43787577, KADM5_LOG_NEEDS_UPGRADE = 43787578 } kadm5_error_number; #define ERROR_TABLE_BASE_kadm5 43787520 #define COM_ERR_BINDDOMAIN_kadm5 "heim_com_err43787520" #endif /* __kadm5_err_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/kadm5/private.h000066400000000000000000000133121505521762700234400ustar00rootroot00000000000000/* * Copyright (c) 1997-2000 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef __kadm5_privatex_h__ #define __kadm5_privatex_h__ #ifdef HAVE_SYS_UN_H #include #endif struct kadm_func { kadm5_ret_t (*chpass_principal) (void *, krb5_principal, int, int, krb5_key_salt_tuple*, const char*); kadm5_ret_t (*create_principal) (void*, kadm5_principal_ent_t, uint32_t, int, krb5_key_salt_tuple *, const char*); kadm5_ret_t (*delete_principal) (void*, krb5_principal); kadm5_ret_t (*destroy) (void*); kadm5_ret_t (*flush) (void*); kadm5_ret_t (*get_principal) (void*, krb5_principal, kadm5_principal_ent_t, uint32_t); kadm5_ret_t (*get_principals) (void*, const char*, char***, int*); kadm5_ret_t (*get_privs) (void*, uint32_t*); kadm5_ret_t (*modify_principal) (void*, kadm5_principal_ent_t, uint32_t); kadm5_ret_t (*randkey_principal) (void*, krb5_principal, krb5_boolean, int, krb5_key_salt_tuple*, krb5_keyblock**, int*); kadm5_ret_t (*rename_principal) (void*, krb5_principal, krb5_principal); kadm5_ret_t (*chpass_principal_with_key) (void *, krb5_principal, int, int, krb5_key_data *); kadm5_ret_t (*lock) (void *); kadm5_ret_t (*unlock) (void *); kadm5_ret_t (*setkey_principal_3) (void *, krb5_principal, krb5_boolean, int, krb5_key_salt_tuple *, krb5_keyblock *, int); }; /* XXX should be integrated */ typedef struct kadm5_common_context { krb5_context context; krb5_boolean my_context; struct kadm_func funcs; void *data; } kadm5_common_context; typedef struct kadm5_log_peer { int fd; char *name; krb5_auth_context ac; struct kadm5_log_peer *next; } kadm5_log_peer; typedef struct kadm5_log_context { char *log_file; int log_fd; int read_only; int lock_mode; uint32_t version; time_t last_time; #ifndef NO_UNIX_SOCKETS struct sockaddr_un socket_name; #else struct addrinfo *socket_info; #endif krb5_socket_t socket_fd; } kadm5_log_context; typedef struct kadm5_server_context { krb5_context context; krb5_boolean my_context; struct kadm_func funcs; /* */ kadm5_config_params config; HDB *db; int keep_open; krb5_principal caller; unsigned acl_flags; kadm5_log_context log_context; } kadm5_server_context; typedef struct kadm5_client_context { krb5_context context; krb5_boolean my_context; struct kadm_func funcs; /* */ krb5_auth_context ac; char *realm; char *admin_server; int kadmind_port; krb5_socket_t sock; char *client_name; char *service_name; krb5_prompter_fct prompter; const char *keytab; krb5_ccache ccache; kadm5_config_params *realm_params; } kadm5_client_context; typedef struct kadm5_ad_context { krb5_context context; krb5_boolean my_context; struct kadm_func funcs; /* */ kadm5_config_params config; krb5_principal caller; krb5_ccache ccache; char *client_name; char *realm; void *ldap_conn; char *base_dn; } kadm5_ad_context; /* * This enum is used in the iprop log file and on the wire in the iprop * protocol. DO NOT CHANGE, except to add new op types at the end, and * look for places in lib/kadm5/log.c to update. */ enum kadm_ops { kadm_get, kadm_delete, kadm_create, kadm_rename, kadm_chpass, kadm_modify, kadm_randkey, kadm_get_privs, kadm_get_princs, kadm_chpass_with_key, kadm_nop, kadm_first = kadm_get, kadm_last = kadm_nop }; /* FIXME nop types are currently not implemented */ enum kadm_nop_type { kadm_nop_plain, /* plain nop, not relevance except as uberblock */ kadm_nop_trunc, /* indicates that the master truncated the log */ kadm_nop_close /* indicates that the master closed this log */ }; enum kadm_iter_opts { kadm_forward = 1, kadm_backward = 2, kadm_confirmed = 4, kadm_unconfirmed = 8 }; enum kadm_recover_mode { kadm_recover_commit, kadm_recover_replay }; #define KADMIN_APPL_VERSION "KADM0.1" #define KADMIN_OLD_APPL_VERSION "KADM0.0" #include "kadm5-private.h" #endif /* __kadm5_privatex_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/kafs.h000066400000000000000000000162711505521762700217200ustar00rootroot00000000000000/* * Copyright (c) 1995 - 2001, 2003 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef __KAFS_H #define __KAFS_H /* XXX must include krb5.h or krb.h */ /* sys/ioctl.h must be included manually before kafs.h */ /* */ #define AFSCALL_PIOCTL 20 #define AFSCALL_SETPAG 21 #ifndef _VICEIOCTL #ifdef __GNU__ #define _IOT_ViceIoctl _IOT(_IOTS(caddr_t), 2, _IOTS(short), 2, 0, 0) #endif #define _VICEIOCTL(id) ((unsigned int ) _IOW('V', id, struct ViceIoctl)) #define _AFSCIOCTL(id) ((unsigned int ) _IOW('C', id, struct ViceIoctl)) #endif /* _VICEIOCTL */ #define VIOCSETAL _VICEIOCTL(1) #define VIOCGETAL _VICEIOCTL(2) #define VIOCSETTOK _VICEIOCTL(3) #define VIOCGETVOLSTAT _VICEIOCTL(4) #define VIOCSETVOLSTAT _VICEIOCTL(5) #define VIOCFLUSH _VICEIOCTL(6) #define VIOCGETTOK _VICEIOCTL(8) #define VIOCUNLOG _VICEIOCTL(9) #define VIOCCKSERV _VICEIOCTL(10) #define VIOCCKBACK _VICEIOCTL(11) #define VIOCCKCONN _VICEIOCTL(12) #define VIOCWHEREIS _VICEIOCTL(14) #define VIOCACCESS _VICEIOCTL(20) #define VIOCUNPAG _VICEIOCTL(21) #define VIOCGETFID _VICEIOCTL(22) #define VIOCSETCACHESIZE _VICEIOCTL(24) #define VIOCFLUSHCB _VICEIOCTL(25) #define VIOCNEWCELL _VICEIOCTL(26) #define VIOCGETCELL _VICEIOCTL(27) #define VIOC_AFS_DELETE_MT_PT _VICEIOCTL(28) #define VIOC_AFS_STAT_MT_PT _VICEIOCTL(29) #define VIOC_FILE_CELL_NAME _VICEIOCTL(30) #define VIOC_GET_WS_CELL _VICEIOCTL(31) #define VIOC_AFS_MARINER_HOST _VICEIOCTL(32) #define VIOC_GET_PRIMARY_CELL _VICEIOCTL(33) #define VIOC_VENUSLOG _VICEIOCTL(34) #define VIOC_GETCELLSTATUS _VICEIOCTL(35) #define VIOC_SETCELLSTATUS _VICEIOCTL(36) #define VIOC_FLUSHVOLUME _VICEIOCTL(37) #define VIOC_AFS_SYSNAME _VICEIOCTL(38) #define VIOC_EXPORTAFS _VICEIOCTL(39) #define VIOCGETCACHEPARAMS _VICEIOCTL(40) #define VIOC_GCPAGS _VICEIOCTL(48) #define VIOCGETTOK2 _AFSCIOCTL(7) #define VIOCSETTOK2 _AFSCIOCTL(8) struct ViceIoctl { caddr_t in, out; unsigned short in_size; unsigned short out_size; }; struct ClearToken { int32_t AuthHandle; char HandShakeKey[8]; int32_t ViceId; int32_t BeginTimestamp; int32_t EndTimestamp; }; /* Use k_hasafs() to probe if the machine supports AFS syscalls. The other functions will generate a SIGSYS if AFS is not supported */ int k_hasafs (void); int k_hasafs_recheck (void); int krb_afslog (const char *cell, const char *realm); int krb_afslog_uid (const char *cell, const char *realm, uid_t uid); int krb_afslog_home (const char *cell, const char *realm, const char *homedir); int krb_afslog_uid_home (const char *cell, const char *realm, uid_t uid, const char *homedir); int krb_realm_of_cell (const char *cell, char **realm); /* compat */ #define k_afsklog krb_afslog #define k_afsklog_uid krb_afslog_uid int k_pioctl (char *a_path, int o_opcode, struct ViceIoctl *a_paramsP, int a_followSymlinks); int k_unlog (void); int k_setpag (void); int k_afs_cell_of_file (const char *path, char *cell, int len); /* XXX */ #ifdef KFAILURE #define KRB_H_INCLUDED #endif #ifdef KRB5_RECVAUTH_IGNORE_VERSION #define KRB5_H_INCLUDED #endif void kafs_set_verbose (void (*kafs_verbose)(void *, const char *), void *); int kafs_settoken_rxkad (const char *, struct ClearToken *, void *ticket, size_t ticket_len); #ifdef KRB_H_INCLUDED int kafs_settoken (const char*, uid_t, CREDENTIALS*); #endif #ifdef KRB5_H_INCLUDED int kafs_settoken5 (krb5_context, const char*, uid_t, krb5_creds*); #endif #ifdef KRB5_H_INCLUDED krb5_error_code krb5_afslog_uid (krb5_context context, krb5_ccache id, const char *cell, krb5_const_realm realm, uid_t uid); krb5_error_code krb5_afslog (krb5_context context, krb5_ccache id, const char *cell, krb5_const_realm realm); krb5_error_code krb5_afslog_uid_home (krb5_context context, krb5_ccache id, const char *cell, krb5_const_realm realm, uid_t uid, const char *homedir); krb5_error_code krb5_afslog_home (krb5_context context, krb5_ccache id, const char *cell, krb5_const_realm realm, const char *homedir); krb5_error_code krb5_realm_of_cell (const char *cell, char **realm); #endif #define _PATH_VICE "/usr/vice/etc/" #define _PATH_THISCELL _PATH_VICE "ThisCell" #define _PATH_CELLSERVDB _PATH_VICE "CellServDB" #define _PATH_THESECELLS _PATH_VICE "TheseCells" #define _PATH_ARLA_VICE "/usr/arla/etc/" #define _PATH_ARLA_THISCELL _PATH_ARLA_VICE "ThisCell" #define _PATH_ARLA_CELLSERVDB _PATH_ARLA_VICE "CellServDB" #define _PATH_ARLA_THESECELLS _PATH_ARLA_VICE "TheseCells" #define _PATH_OPENAFS_DEBIAN_VICE "/etc/openafs/" #define _PATH_OPENAFS_DEBIAN_THISCELL _PATH_OPENAFS_DEBIAN_VICE "ThisCell" #define _PATH_OPENAFS_DEBIAN_CELLSERVDB _PATH_OPENAFS_DEBIAN_VICE "CellServDB" #define _PATH_OPENAFS_DEBIAN_THESECELLS _PATH_OPENAFS_DEBIAN_VICE "TheseCells" #define _PATH_OPENAFS_MACOSX_VICE "/var/db/openafs/etc/" #define _PATH_OPENAFS_MACOSX_THISCELL _PATH_OPENAFS_MACOSX_VICE "ThisCell" #define _PATH_OPENAFS_MACOSX_CELLSERVDB _PATH_OPENAFS_MACOSX_VICE "CellServDB" #define _PATH_OPENAFS_MACOSX_THESECELLS _PATH_OPENAFS_MACOSX_VICE "TheseCells" #define _PATH_ARLA_DEBIAN_VICE "/etc/arla/" #define _PATH_ARLA_DEBIAN_THISCELL _PATH_ARLA_DEBIAN_VICE "ThisCell" #define _PATH_ARLA_DEBIAN_CELLSERVDB _PATH_ARLA_DEBIAN_VICE "CellServDB" #define _PATH_ARLA_DEBIAN_THESECELLS _PATH_ARLA_DEBIAN_VICE "TheseCells" #define _PATH_ARLA_OPENBSD_VICE "/etc/afs/" #define _PATH_ARLA_OPENBSD_THISCELL _PATH_ARLA_OPENBSD_VICE "ThisCell" #define _PATH_ARLA_OPENBSD_CELLSERVDB _PATH_ARLA_OPENBSD_VICE "CellServDB" #define _PATH_ARLA_OPENBSD_THESECELLS _PATH_ARLA_OPENBSD_VICE "TheseCells" extern int _kafs_debug; #endif /* __KAFS_H */ pykrb5-0.8.0/build_helpers/heimdal/include/kdc-protos.h000066400000000000000000000046461505521762700230640ustar00rootroot00000000000000/* This is a generated file */ #ifndef __kdc_protos_h__ #define __kdc_protos_h__ #ifndef DOXY #include #ifdef __cplusplus extern "C" { #endif krb5_error_code kdc_check_flags ( krb5_context /*context*/, krb5_kdc_configuration */*config*/, hdb_entry_ex */*client_ex*/, const char */*client_name*/, hdb_entry_ex */*server_ex*/, const char */*server_name*/, krb5_boolean /*is_as_req*/); krb5_error_code kdc_kx509_verify_service_principal ( krb5_context /*context*/, const char */*cname*/, krb5_principal /*sprincipal*/); void kdc_log ( krb5_context /*context*/, krb5_kdc_configuration */*config*/, int /*level*/, const char */*fmt*/, ...); char* kdc_log_msg ( krb5_context /*context*/, krb5_kdc_configuration */*config*/, int /*level*/, const char */*fmt*/, ...); char* kdc_log_msg_va ( krb5_context /*context*/, krb5_kdc_configuration */*config*/, int /*level*/, const char */*fmt*/, va_list /*ap*/); void kdc_openlog ( krb5_context /*context*/, const char */*service*/, krb5_kdc_configuration */*config*/); krb5_error_code krb5_kdc_get_config ( krb5_context /*context*/, krb5_kdc_configuration **/*config*/); krb5_error_code krb5_kdc_pk_initialize ( krb5_context /*context*/, krb5_kdc_configuration */*config*/, const char */*user_id*/, const char */*anchors*/, char **/*pool*/, char **/*revoke_list*/); krb5_error_code krb5_kdc_pkinit_config ( krb5_context /*context*/, krb5_kdc_configuration */*config*/); int krb5_kdc_process_krb5_request ( krb5_context /*context*/, krb5_kdc_configuration */*config*/, unsigned char */*buf*/, size_t /*len*/, krb5_data */*reply*/, const char */*from*/, struct sockaddr */*addr*/, int /*datagram_reply*/); int krb5_kdc_process_request ( krb5_context /*context*/, krb5_kdc_configuration */*config*/, unsigned char */*buf*/, size_t /*len*/, krb5_data */*reply*/, krb5_boolean */*prependlength*/, const char */*from*/, struct sockaddr */*addr*/, int /*datagram_reply*/); int krb5_kdc_save_request ( krb5_context /*context*/, const char */*fn*/, const unsigned char */*buf*/, size_t /*len*/, const krb5_data */*reply*/, const struct sockaddr */*sa*/); krb5_error_code krb5_kdc_set_dbinfo ( krb5_context /*context*/, struct krb5_kdc_configuration */*c*/); void krb5_kdc_update_time (struct timeval */*tv*/); krb5_error_code krb5_kdc_windc_init (krb5_context /*context*/); #ifdef __cplusplus } #endif #endif /* DOXY */ #endif /* __kdc_protos_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/kdc.h000066400000000000000000000070731505521762700215350ustar00rootroot00000000000000/* * Copyright (c) 1997-2003 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * * Copyright (c) 2005 Andrew Bartlett * * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * $Id$ */ #ifndef __KDC_H__ #define __KDC_H__ #include #include enum krb5_kdc_trpolicy { TRPOLICY_ALWAYS_CHECK, TRPOLICY_ALLOW_PER_PRINCIPAL, TRPOLICY_ALWAYS_HONOUR_REQUEST }; typedef struct krb5_kdc_configuration { krb5_boolean require_preauth; /* require preauth for all principals */ time_t kdc_warn_pwexpire; /* time before expiration to print a warning */ struct HDB **db; int num_db; int num_kdc_processes; krb5_boolean encode_as_rep_as_tgs_rep; /* bug compatibility */ krb5_boolean tgt_use_strongest_session_key; krb5_boolean preauth_use_strongest_session_key; krb5_boolean svc_use_strongest_session_key; krb5_boolean use_strongest_server_key; krb5_boolean check_ticket_addresses; krb5_boolean allow_null_ticket_addresses; krb5_boolean allow_anonymous; krb5_boolean strict_nametypes; enum krb5_kdc_trpolicy trpolicy; krb5_boolean enable_pkinit; krb5_boolean pkinit_princ_in_cert; const char *pkinit_kdc_identity; const char *pkinit_kdc_anchors; const char *pkinit_kdc_friendly_name; const char *pkinit_kdc_ocsp_file; char **pkinit_kdc_cert_pool; char **pkinit_kdc_revoke; int pkinit_dh_min_bits; int pkinit_require_binding; int pkinit_allow_proxy_certs; krb5_log_facility *logf; int enable_digest; int digests_allowed; size_t max_datagram_reply_length; int enable_kx509; const char *kx509_template; const char *kx509_ca; } krb5_kdc_configuration; struct krb5_kdc_service { unsigned int flags; #define KS_KRB5 1 #define KS_NO_LENGTH 2 krb5_error_code (*process)(krb5_context context, krb5_kdc_configuration *config, krb5_data *req_buffer, krb5_data *reply, const char *from, struct sockaddr *addr, int datagram_reply, int *claim); }; #include #endif pykrb5-0.8.0/build_helpers/heimdal/include/krb5-protos.h000066400000000000000000007264611505521762700231740ustar00rootroot00000000000000/* This is a generated file */ #ifndef __krb5_protos_h__ #define __krb5_protos_h__ #ifndef DOXY #include #if !defined(__GNUC__) && !defined(__attribute__) #define __attribute__(x) #endif #ifndef KRB5_DEPRECATED_FUNCTION #ifndef __has_extension #define __has_extension(x) 0 #define KRB5_DEPRECATED_FUNCTIONhas_extension 1 #endif #if __has_extension(attribute_deprecated_with_message) #define KRB5_DEPRECATED_FUNCTION(x) __attribute__((__deprecated__(x))) #elif defined(__GNUC__) && ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1 ))) #define KRB5_DEPRECATED_FUNCTION(X) __attribute__((__deprecated__)) #else #define KRB5_DEPRECATED_FUNCTION(X) #endif #ifdef KRB5_DEPRECATED_FUNCTIONhas_extension #undef __has_extension #undef KRB5_DEPRECATED_FUNCTIONhas_extension #endif #endif /* KRB5_DEPRECATED_FUNCTION */ #ifdef __cplusplus extern "C" { #endif #ifndef KRB5_LIB #ifndef KRB5_LIB_FUNCTION #if defined(_WIN32) #define KRB5_LIB_FUNCTION __declspec(dllimport) #define KRB5_LIB_CALL __stdcall #define KRB5_LIB_VARIABLE __declspec(dllimport) #else #define KRB5_LIB_FUNCTION #define KRB5_LIB_CALL #define KRB5_LIB_VARIABLE #endif #endif #endif /** * Convert the v5 credentials in in_cred to v4-dito in v4creds. This * is done by sending them to the 524 function in the KDC. If * `in_cred' doesn't contain a DES session key, then a new one is * gotten from the KDC and stored in the cred cache `ccache'. * * @param context Kerberos 5 context. * @param in_cred the credential to convert * @param v4creds the converted credential * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5_v4compat */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb524_convert_creds_kdc ( krb5_context /*context*/, krb5_creds */*in_cred*/, struct credentials */*v4creds*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Convert the v5 credentials in in_cred to v4-dito in v4creds, * check the credential cache ccache before checking with the KDC. * * @param context Kerberos 5 context. * @param ccache credential cache used to check for des-ticket. * @param in_cred the credential to convert * @param v4creds the converted credential * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5_v4compat */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb524_convert_creds_kdc_ccache ( krb5_context /*context*/, krb5_ccache /*ccache*/, krb5_creds */*in_cred*/, struct credentials */*v4creds*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Log a warning to the log, default stderr, include the error from * the last failure and then abort. * * @param context A Kerberos 5 context * @param code error code of the last error * @param fmt message to print * @param ... arguments for format string * * @ingroup krb5_error */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_abort ( krb5_context /*context*/, krb5_error_code /*code*/, const char */*fmt*/, ...) __attribute__ ((__noreturn__, __format__ (__printf__, 3, 4))); /** * Log a warning to the log, default stderr, and then abort. * * @param context A Kerberos 5 context * @param fmt printf format string of message to print * @param ... arguments for format string * * @ingroup krb5_error */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_abortx ( krb5_context /*context*/, const char */*fmt*/, ...) __attribute__ ((__noreturn__, __format__ (__printf__, 2, 3))); /** * krb5_acl_match_file matches ACL format against each line in a file * using krb5_acl_match_string(). Lines starting with # are treated * like comments and ignored. * * @param context Kerberos 5 context. * @param file file with acl listed in the file. * @param format format to match. * @param ... parameter to format string. * * @return Return an error code or 0. * * @sa krb5_acl_match_string * @ingroup krb5_support */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_acl_match_file ( krb5_context /*context*/, const char */*file*/, const char */*format*/, ...); /** * krb5_acl_match_string matches ACL format against a string. * * The ACL format has three format specifiers: s, f, and r. Each * specifier will retrieve one argument from the variable arguments * for either matching or storing data. The input string is split up * using " " (space) and "\t" (tab) as a delimiter; multiple and "\t" * in a row are considered to be the same. * * List of format specifiers: * - s Matches a string using strcmp(3) (case sensitive). * - f Matches the string with fnmatch(3). Theflags * argument (the last argument) passed to the fnmatch function is 0. * - r Returns a copy of the string in the char ** passed in; the copy * must be freed with free(3). There is no need to free(3) the * string on error: the function will clean up and set the pointer * to NULL. * * @param context Kerberos 5 context * @param string string to match with * @param format format to match * @param ... parameter to format string * * @return Return an error code or 0. * * * @code * char *s; * * ret = krb5_acl_match_string(context, "foo", "s", "foo"); * if (ret) * krb5_errx(context, 1, "acl didn't match"); * ret = krb5_acl_match_string(context, "foo foo baz/kaka", * "ss", "foo", &s, "foo/\\*"); * if (ret) { * // no need to free(s) on error * assert(s == NULL); * krb5_errx(context, 1, "acl didn't match"); * } * free(s); * @endcode * * @sa krb5_acl_match_file * @ingroup krb5_support */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_acl_match_string ( krb5_context /*context*/, const char */*string*/, const char */*format*/, ...); /** * Add a specified list of error messages to the et list in context. * Call func (probably a comerr-generated function) with a pointer to * the current et_list. * * @param context A kerberos context. * @param func The generated com_err et function. * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_add_et_list ( krb5_context /*context*/, void (*/*func*/)(struct et_list **)); /** * Add extra address to the address list that the library will add to * the client's address list when communicating with the KDC. * * @param context Kerberos 5 context. * @param addresses addreses to add * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_add_extra_addresses ( krb5_context /*context*/, krb5_addresses */*addresses*/); /** * Add extra addresses to ignore when fetching addresses from the * underlaying operating system. * * @param context Kerberos 5 context. * @param addresses addreses to ignore * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_add_ignore_addresses ( krb5_context /*context*/, krb5_addresses */*addresses*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_addlog_dest ( krb5_context /*context*/, krb5_log_facility */*f*/, const char */*orig*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_addlog_func ( krb5_context /*context*/, krb5_log_facility */*fac*/, int /*min*/, int /*max*/, krb5_log_log_func_t /*log_func*/, krb5_log_close_func_t /*close_func*/, void */*data*/); /** * krb5_addr2sockaddr sets the "struct sockaddr sockaddr" from addr * and port. The argument sa_size should initially contain the size of * the sa and after the call, it will contain the actual length of the * address. In case of the sa is too small to fit the whole address, * the up to *sa_size will be stored, and then *sa_size will be set to * the required length. * * @param context a Keberos context * @param addr the address to copy the from * @param sa the struct sockaddr that will be filled in * @param sa_size pointer to length of sa, and after the call, it will * contain the actual length of the address. * @param port set port in sa. * * @return Return an error code or 0. Will return * KRB5_PROG_ATYPE_NOSUPP in case address type is not supported. * * @ingroup krb5_address */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_addr2sockaddr ( krb5_context /*context*/, const krb5_address */*addr*/, struct sockaddr */*sa*/, krb5_socklen_t */*sa_size*/, int /*port*/); /** * krb5_address_compare compares the addresses addr1 and addr2. * Returns TRUE if the two addresses are the same. * * @param context a Keberos context * @param addr1 address to compare * @param addr2 address to compare * * @return Return an TRUE is the address are the same FALSE if not * * @ingroup krb5_address */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_address_compare ( krb5_context /*context*/, const krb5_address */*addr1*/, const krb5_address */*addr2*/); /** * krb5_address_order compares the addresses addr1 and addr2 so that * it can be used for sorting addresses. If the addresses are the same * address krb5_address_order will return 0. Behavies like memcmp(2). * * @param context a Keberos context * @param addr1 krb5_address to compare * @param addr2 krb5_address to compare * * @return < 0 if address addr1 in "less" then addr2. 0 if addr1 and * addr2 is the same address, > 0 if addr2 is "less" then addr1. * * @ingroup krb5_address */ KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_address_order ( krb5_context /*context*/, const krb5_address */*addr1*/, const krb5_address */*addr2*/); /** * Calculate the boundary addresses of `inaddr'/`prefixlen' and store * them in `low' and `high'. * * @param context a Keberos context * @param inaddr address in prefixlen that the bondery searched * @param prefixlen width of boundery * @param low lowest address * @param high highest address * * @return Return an error code or 0. * * @ingroup krb5_address */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_address_prefixlen_boundary ( krb5_context /*context*/, const krb5_address */*inaddr*/, unsigned long /*prefixlen*/, krb5_address */*low*/, krb5_address */*high*/); /** * krb5_address_search checks if the address addr is a member of the * address set list addrlist . * * @param context a Keberos context. * @param addr address to search for. * @param addrlist list of addresses to look in for addr. * * @return Return an error code or 0. * * @ingroup krb5_address */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_address_search ( krb5_context /*context*/, const krb5_address */*addr*/, const krb5_addresses */*addrlist*/); /** * Enable or disable all weak encryption types * * @param context Kerberos 5 context * @param enable true to enable, false to disable * * @return Return an error code or 0. * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_allow_weak_crypto ( krb5_context /*context*/, krb5_boolean /*enable*/); /** * Map a principal name to a local username. * * Returns 0 on success, KRB5_NO_LOCALNAME if no mapping was found, or * some Kerberos or system error. * * Inputs: * * @param context A krb5_context * @param aname A principal name * @param lnsize The size of the buffer into which the username will be written * @param lname The buffer into which the username will be written * * @ingroup krb5_support */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_aname_to_localname ( krb5_context /*context*/, krb5_const_principal /*aname*/, size_t /*lnsize*/, char */*lname*/); /** * krb5_anyaddr fills in a "struct sockaddr sa" that can be used to * bind(2) to. The argument sa_size should initially contain the size * of the sa, and after the call, it will contain the actual length * of the address. * * @param context a Keberos context * @param af address family * @param sa sockaddr * @param sa_size lenght of sa. * @param port for to fill into sa. * * @return Return an error code or 0. * * @ingroup krb5_address */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_anyaddr ( krb5_context /*context*/, int /*af*/, struct sockaddr */*sa*/, krb5_socklen_t */*sa_size*/, int /*port*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_appdefault_boolean ( krb5_context /*context*/, const char */*appname*/, krb5_const_realm /*realm*/, const char */*option*/, krb5_boolean /*def_val*/, krb5_boolean */*ret_val*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_appdefault_string ( krb5_context /*context*/, const char */*appname*/, krb5_const_realm /*realm*/, const char */*option*/, const char */*def_val*/, char **/*ret_val*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_appdefault_time ( krb5_context /*context*/, const char */*appname*/, krb5_const_realm /*realm*/, const char */*option*/, time_t /*def_val*/, time_t */*ret_val*/); /** * krb5_append_addresses adds the set of addresses in source to * dest. While copying the addresses, duplicates are also sorted out. * * @param context a Keberos context * @param dest destination of copy operation * @param source adresses that are going to be added to dest * * @return Return an error code or 0. * * @ingroup krb5_address */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_append_addresses ( krb5_context /*context*/, krb5_addresses */*dest*/, const krb5_addresses */*source*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_add_AuthorizationData ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, int /*type*/, krb5_data */*data*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_addflags ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, int32_t /*addflags*/, int32_t */*flags*/); /** * Deallocate an authentication context previously initialized with * krb5_auth_con_init(). * * @param context A kerberos context. * @param auth_context The authentication context to be deallocated. * * @return An krb5 error code, see krb5_get_error_message(). */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_free ( krb5_context /*context*/, krb5_auth_context /*auth_context*/); /** * Update the authentication context \a auth_context with the local * and remote addresses from socket \a fd, according to \a flags. * * @return An krb5 error code, see krb5_get_error_message(). */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_genaddrs ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_socket_t /*fd*/, int /*flags*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_generatelocalsubkey ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_keyblock */*key*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_getaddrs ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_address **/*local_addr*/, krb5_address **/*remote_addr*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_getauthenticator ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_authenticator */*authenticator*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_getcksumtype ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_cksumtype */*cksumtype*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_getflags ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, int32_t */*flags*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_getkey ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_keyblock **/*keyblock*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_getkeytype ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_keytype */*keytype*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_getlocalseqnumber ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, int32_t */*seqnumber*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_getlocalsubkey ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_keyblock **/*keyblock*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_getrcache ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_rcache */*rcache*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_getrecvsubkey ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_keyblock **/*keyblock*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_getremoteseqnumber ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, int32_t */*seqnumber*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_getremotesubkey ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_keyblock **/*keyblock*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_getsendsubkey ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_keyblock **/*keyblock*/); /** * Allocate and initialize an autentication context. * * @param context A kerberos context. * @param auth_context The authentication context to be initialized. * * Use krb5_auth_con_free() to release the memory when done using the context. * * @return An krb5 error code, see krb5_get_error_message(). */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_init ( krb5_context /*context*/, krb5_auth_context */*auth_context*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_removeflags ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, int32_t /*removeflags*/, int32_t */*flags*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_setaddrs ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_address */*local_addr*/, krb5_address */*remote_addr*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_setaddrs_from_fd ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, void */*p_fd*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_setcksumtype ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_cksumtype /*cksumtype*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_setflags ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, int32_t /*flags*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_setkey ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_keyblock */*keyblock*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_setkeytype ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_keytype /*keytype*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_setlocalseqnumber ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, int32_t /*seqnumber*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_setlocalsubkey ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_keyblock */*keyblock*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_setrcache ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_rcache /*rcache*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_setrecvsubkey ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_keyblock */*keyblock*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_setremoteseqnumber ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, int32_t /*seqnumber*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_setremotesubkey ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_keyblock */*keyblock*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_setsendsubkey ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_keyblock */*keyblock*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_con_setuserkey ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_keyblock */*keyblock*/); /** * Deprecated: use krb5_auth_con_getremoteseqnumber() * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_auth_getremoteseqnumber ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, int32_t */*seqnumber*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_build_ap_req ( krb5_context /*context*/, krb5_enctype /*enctype*/, krb5_creds */*cred*/, krb5_flags /*ap_options*/, krb5_data /*authenticator*/, krb5_data */*retdata*/); /** * Build a principal using vararg style building * * @param context A Kerberos context. * @param principal returned principal * @param rlen length of realm * @param realm realm name * @param ... a list of components ended with NULL. * * @return An krb5 error code, see krb5_get_error_message(). * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_build_principal ( krb5_context /*context*/, krb5_principal */*principal*/, int /*rlen*/, krb5_const_realm /*realm*/, ...); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_build_principal_ext ( krb5_context /*context*/, krb5_principal */*principal*/, int /*rlen*/, krb5_const_realm /*realm*/, ...); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_build_principal_va ( krb5_context /*context*/, krb5_principal */*principal*/, int /*rlen*/, krb5_const_realm /*realm*/, va_list /*ap*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_build_principal_va_ext ( krb5_context /*context*/, krb5_principal */*principal*/, int /*rlen*/, krb5_const_realm /*realm*/, va_list /*ap*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_c_block_size ( krb5_context /*context*/, krb5_enctype /*enctype*/, size_t */*blocksize*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_c_checksum_length ( krb5_context /*context*/, krb5_cksumtype /*cksumtype*/, size_t */*length*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_c_decrypt ( krb5_context /*context*/, const krb5_keyblock /*key*/, krb5_keyusage /*usage*/, const krb5_data */*ivec*/, krb5_enc_data */*input*/, krb5_data */*output*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_c_encrypt ( krb5_context /*context*/, const krb5_keyblock */*key*/, krb5_keyusage /*usage*/, const krb5_data */*ivec*/, const krb5_data */*input*/, krb5_enc_data */*output*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_c_encrypt_length ( krb5_context /*context*/, krb5_enctype /*enctype*/, size_t /*inputlen*/, size_t */*length*/); /** * Deprecated: keytypes doesn't exists, they are really enctypes. * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_c_enctype_compare ( krb5_context /*context*/, krb5_enctype /*e1*/, krb5_enctype /*e2*/, krb5_boolean */*similar*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_c_get_checksum ( krb5_context /*context*/, const krb5_checksum */*cksum*/, krb5_cksumtype */*type*/, krb5_data **/*data*/); KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_c_is_coll_proof_cksum (krb5_cksumtype /*ctype*/); KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_c_is_keyed_cksum (krb5_cksumtype /*ctype*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_c_keylengths ( krb5_context /*context*/, krb5_enctype /*enctype*/, size_t */*ilen*/, size_t */*keylen*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_c_make_checksum ( krb5_context /*context*/, krb5_cksumtype /*cksumtype*/, const krb5_keyblock */*key*/, krb5_keyusage /*usage*/, const krb5_data */*input*/, krb5_checksum */*cksum*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_c_make_random_key ( krb5_context /*context*/, krb5_enctype /*enctype*/, krb5_keyblock */*random_key*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_c_prf ( krb5_context /*context*/, const krb5_keyblock */*key*/, const krb5_data */*input*/, krb5_data */*output*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_c_prf_length ( krb5_context /*context*/, krb5_enctype /*type*/, size_t */*length*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_c_random_make_octets ( krb5_context /*context*/, krb5_data * /*data*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_c_set_checksum ( krb5_context /*context*/, krb5_checksum */*cksum*/, krb5_cksumtype /*type*/, const krb5_data */*data*/); KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_c_valid_cksumtype (krb5_cksumtype /*ctype*/); KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_c_valid_enctype (krb5_enctype /*etype*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_c_verify_checksum ( krb5_context /*context*/, const krb5_keyblock */*key*/, krb5_keyusage /*usage*/, const krb5_data */*data*/, const krb5_checksum */*cksum*/, krb5_boolean */*valid*/); /** * Destroy the cursor `cursor'. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_cache_end_seq_get ( krb5_context /*context*/, krb5_cc_cache_cursor /*cursor*/); /** * Start iterating over all caches of specified type. See also * krb5_cccol_cursor_new(). * @param context A Kerberos 5 context * @param type optional type to iterate over, if NULL, the default cache is used. * @param cursor cursor should be freed with krb5_cc_cache_end_seq_get(). * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_cache_get_first ( krb5_context /*context*/, const char */*type*/, krb5_cc_cache_cursor */*cursor*/); /** * Search for a matching credential cache that have the * `principal' as the default principal. On success, `id' needs to be * freed with krb5_cc_close() or krb5_cc_destroy(). * * @param context A Kerberos 5 context * @param client The principal to search for * @param id the returned credential cache * * @return On failure, error code is returned and `id' is set to NULL. * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_cache_match ( krb5_context /*context*/, krb5_principal /*client*/, krb5_ccache */*id*/); /** * Retrieve the next cache pointed to by (`cursor') in `id' * and advance `cursor'. * * @param context A Kerberos 5 context * @param cursor the iterator cursor, returned by krb5_cc_cache_get_first() * @param id next ccache * * @return Return 0 or an error code. Returns KRB5_CC_END when the end * of caches is reached, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_cache_next ( krb5_context /*context*/, krb5_cc_cache_cursor /*cursor*/, krb5_ccache */*id*/); /** * Clear `mcreds' so it can be used with krb5_cc_retrieve_cred * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_cc_clear_mcred (krb5_creds */*mcred*/); /** * Stop using the ccache `id' and free the related resources. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_close ( krb5_context /*context*/, krb5_ccache /*id*/); /** * Just like krb5_cc_copy_match_f(), but copy everything. * * @ingroup @krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_copy_cache ( krb5_context /*context*/, const krb5_ccache /*from*/, krb5_ccache /*to*/); /** * MIT compat glue * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_copy_creds ( krb5_context /*context*/, const krb5_ccache /*from*/, krb5_ccache /*to*/); /** * Copy the contents of `from' to `to' if the given match function * return true. * * @param context A Kerberos 5 context. * @param from the cache to copy data from. * @param to the cache to copy data to. * @param match a match function that should return TRUE if cred argument should be copied, if NULL, all credentials are copied. * @param matchctx context passed to match function. * @param matched set to true if there was a credential that matched, may be NULL. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_copy_match_f ( krb5_context /*context*/, const krb5_ccache /*from*/, krb5_ccache /*to*/, krb5_boolean (*/*match*/)(krb5_context, void *, const krb5_creds *), void */*matchctx*/, unsigned int */*matched*/); /** * Open the default ccache in `id'. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_default ( krb5_context /*context*/, krb5_ccache */*id*/); /** * Return a pointer to a context static string containing the default * ccache name. * * @return String to the default credential cache name. * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL krb5_cc_default_name (krb5_context /*context*/); /** * Remove the ccache `id'. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_destroy ( krb5_context /*context*/, krb5_ccache /*id*/); /** * Destroy the cursor `cursor'. * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_end_seq_get ( krb5_context /*context*/, const krb5_ccache /*id*/, krb5_cc_cursor */*cursor*/); /** * Generate a new ccache of type `ops' in `id'. * * Deprecated: use krb5_cc_new_unique() instead. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_gen_new ( krb5_context /*context*/, const krb5_cc_ops */*ops*/, krb5_ccache */*id*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Get some configuration for the credential cache in the cache. * * @param context a Keberos context * @param id the credential cache to store the data for * @param principal configuration for a specific principal, if * NULL, global for the whole cache. * @param name name under which the configuraion is stored. * @param data data to fetched, free with krb5_data_free() * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_get_config ( krb5_context /*context*/, krb5_ccache /*id*/, krb5_const_principal /*principal*/, const char */*name*/, krb5_data */*data*/); /** * Get the flags of `id', store them in `flags'. * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_get_flags ( krb5_context /*context*/, krb5_ccache /*id*/, krb5_flags */*flags*/); /** * Return a friendly name on credential cache. Free the result with krb5_xfree(). * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_get_friendly_name ( krb5_context /*context*/, krb5_ccache /*id*/, char **/*name*/); /** * Return the complete resolvable name the cache * @param context a Keberos context * @param id return pointer to a found credential cache * @param str the returned name of a credential cache, free with krb5_xfree() * * @return Returns 0 or an error (and then *str is set to NULL). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_get_full_name ( krb5_context /*context*/, krb5_ccache /*id*/, char **/*str*/); /** * Get the time offset betwen the client and the KDC * * If the backend doesn't support KDC offset, use the context global setting. * * @param context A Kerberos 5 context. * @param id a credential cache * @param offset the offset in seconds * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_get_kdc_offset ( krb5_context /*context*/, krb5_ccache /*id*/, krb5_deltat */*offset*/); /** * Get the lifetime of the initial ticket in the cache * * Get the lifetime of the initial ticket in the cache, if the initial * ticket was not found, the error code KRB5_CC_END is returned. * * @param context A Kerberos 5 context. * @param id a credential cache * @param t the relative lifetime of the initial ticket * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_get_lifetime ( krb5_context /*context*/, krb5_ccache /*id*/, time_t */*t*/); /** * Return the name of the ccache `id' * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL krb5_cc_get_name ( krb5_context /*context*/, krb5_ccache /*id*/); /** * Return krb5_cc_ops of a the ccache `id'. * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION const krb5_cc_ops * KRB5_LIB_CALL krb5_cc_get_ops ( krb5_context /*context*/, krb5_ccache /*id*/); /** * Get the cc ops that is registered in `context' to handle the * prefix. prefix can be a complete credential cache name or a * prefix, the function will only use part up to the first colon (:) * if there is one. If prefix the argument is NULL, the default ccache * implemtation is returned. * * @return Returns NULL if ops not found. * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION const krb5_cc_ops * KRB5_LIB_CALL krb5_cc_get_prefix_ops ( krb5_context /*context*/, const char */*prefix*/); /** * Return the principal of `id' in `principal'. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_get_principal ( krb5_context /*context*/, krb5_ccache /*id*/, krb5_principal */*principal*/); /** * Return the type of the ccache `id'. * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL krb5_cc_get_type ( krb5_context /*context*/, krb5_ccache /*id*/); /** * Return the version of `id'. * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_get_version ( krb5_context /*context*/, const krb5_ccache /*id*/); /** * Create a new ccache in `id' for `primary_principal'. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_initialize ( krb5_context /*context*/, krb5_ccache /*id*/, krb5_principal /*primary_principal*/); /** * Return the last time the credential cache was modified. * * @param context A Kerberos 5 context * @param id The credential cache to probe * @param mtime the last modification time, set to 0 on error. * @return Return 0 or and error. See krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_last_change_time ( krb5_context /*context*/, krb5_ccache /*id*/, krb5_timestamp */*mtime*/); /** * Move the content from one credential cache to another. The * operation is an atomic switch. * * @param context a Keberos context * @param from the credential cache to move the content from * @param to the credential cache to move the content to * @return On sucess, from is freed. On failure, error code is * returned and from and to are both still allocated, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_move ( krb5_context /*context*/, krb5_ccache /*from*/, krb5_ccache /*to*/); /** * Generates a new unique ccache of `type` in `id'. If `type' is NULL, * the library chooses the default credential cache type. The supplied * `hint' (that can be NULL) is a string that the credential cache * type can use to base the name of the credential on, this is to make * it easier for the user to differentiate the credentials. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_new_unique ( krb5_context /*context*/, const char */*type*/, const char */*hint*/, krb5_ccache */*id*/); /** * Retrieve the next cred pointed to by (`id', `cursor') in `creds' * and advance `cursor'. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_next_cred ( krb5_context /*context*/, const krb5_ccache /*id*/, krb5_cc_cursor */*cursor*/, krb5_creds */*creds*/); /** * Add a new ccache type with operations `ops', overwriting any * existing one if `override'. * * @param context a Keberos context * @param ops type of plugin symbol * @param override flag to select if the registration is to overide * an existing ops with the same name. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_register ( krb5_context /*context*/, const krb5_cc_ops */*ops*/, krb5_boolean /*override*/); /** * Remove the credential identified by `cred', `which' from `id'. * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_remove_cred ( krb5_context /*context*/, krb5_ccache /*id*/, krb5_flags /*which*/, krb5_creds */*cred*/); /** * Find and allocate a ccache in `id' from the specification in `residual'. * If the ccache name doesn't contain any colon, interpret it as a file name. * * @param context a Keberos context. * @param name string name of a credential cache. * @param id return pointer to a found credential cache. * * @return Return 0 or an error code. In case of an error, id is set * to NULL, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_resolve ( krb5_context /*context*/, const char */*name*/, krb5_ccache */*id*/); /** * Retrieve the credential identified by `mcreds' (and `whichfields') * from `id' in `creds'. 'creds' must be free by the caller using * krb5_free_cred_contents. * * @param context A Kerberos 5 context * @param id a Kerberos 5 credential cache * @param whichfields what fields to use for matching credentials, same * flags as whichfields in krb5_compare_creds() * @param mcreds template credential to use for comparing * @param creds returned credential, free with krb5_free_cred_contents() * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_retrieve_cred ( krb5_context /*context*/, krb5_ccache /*id*/, krb5_flags /*whichfields*/, const krb5_creds */*mcreds*/, krb5_creds */*creds*/); /** * Store some configuration for the credential cache in the cache. * Existing configuration under the same name is over-written. * * @param context a Keberos context * @param id the credential cache to store the data for * @param principal configuration for a specific principal, if * NULL, global for the whole cache. * @param name name under which the configuraion is stored. * @param data data to store, if NULL, configure is removed. * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_set_config ( krb5_context /*context*/, krb5_ccache /*id*/, krb5_const_principal /*principal*/, const char */*name*/, krb5_data */*data*/); /** * Set the default cc name for `context' to `name'. * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_set_default_name ( krb5_context /*context*/, const char */*name*/); /** * Set the flags of `id' to `flags'. * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_set_flags ( krb5_context /*context*/, krb5_ccache /*id*/, krb5_flags /*flags*/); /** * Set the friendly name on credential cache. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_set_friendly_name ( krb5_context /*context*/, krb5_ccache /*id*/, const char */*name*/); /** * Set the time offset betwen the client and the KDC * * If the backend doesn't support KDC offset, use the context global setting. * * @param context A Kerberos 5 context. * @param id a credential cache * @param offset the offset in seconds * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_set_kdc_offset ( krb5_context /*context*/, krb5_ccache /*id*/, krb5_deltat /*offset*/); /** * Start iterating over `id', `cursor' is initialized to the * beginning. Caller must free the cursor with krb5_cc_end_seq_get(). * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_start_seq_get ( krb5_context /*context*/, const krb5_ccache /*id*/, krb5_cc_cursor */*cursor*/); /** * Store `creds' in the ccache `id'. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_store_cred ( krb5_context /*context*/, krb5_ccache /*id*/, krb5_creds */*creds*/); /** * Return true if the default credential cache support switch * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_cc_support_switch ( krb5_context /*context*/, const char */*type*/); /** * Switch the default default credential cache for a specific * credcache type (and name for some implementations). * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cc_switch ( krb5_context /*context*/, krb5_ccache /*id*/); /** * End an iteration and free all resources, can be done before end is reached. * * @param context A Kerberos 5 context * @param cursor the iteration cursor to be freed. * * @return Return 0 or and error, KRB5_CC_END is returned at the end * of iteration. See krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cccol_cursor_free ( krb5_context /*context*/, krb5_cccol_cursor */*cursor*/); /** * Get a new cache interation cursor that will interate over all * credentials caches independent of type. * * @param context a Keberos context * @param cursor passed into krb5_cccol_cursor_next() and free with krb5_cccol_cursor_free(). * * @return Returns 0 or and error code, see krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cccol_cursor_new ( krb5_context /*context*/, krb5_cccol_cursor */*cursor*/); /** * Get next credential cache from the iteration. * * @param context A Kerberos 5 context * @param cursor the iteration cursor * @param cache the returned cursor, pointer is set to NULL on failure * and a cache on success. The returned cache needs to be freed * with krb5_cc_close() or destroyed with krb5_cc_destroy(). * MIT Kerberos behavies slightly diffrent and sets cache to NULL * when all caches are iterated over and return 0. * * @return Return 0 or and error, KRB5_CC_END is returned at the end * of iteration. See krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cccol_cursor_next ( krb5_context /*context*/, krb5_cccol_cursor /*cursor*/, krb5_ccache */*cache*/); /** * Return the last modfication time for a cache collection. The query * can be limited to a specific cache type. If the function return 0 * and mtime is 0, there was no credentials in the caches. * * @param context A Kerberos 5 context * @param type The credential cache to probe, if NULL, all type are traversed. * @param mtime the last modification time, set to 0 on error. * @return Return 0 or and error. See krb5_get_error_message(). * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cccol_last_change_time ( krb5_context /*context*/, const char */*type*/, krb5_timestamp */*mtime*/); /** * Deprecated: krb5_change_password() is deprecated, use krb5_set_password(). * * @param context a Keberos context * @param creds * @param newpw * @param result_code * @param result_code_string * @param result_string * * @return On sucess password is changed. * @ingroup @krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_change_password ( krb5_context /*context*/, krb5_creds */*creds*/, const char */*newpw*/, int */*result_code*/, krb5_data */*result_code_string*/, krb5_data */*result_string*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_check_transited ( krb5_context /*context*/, krb5_const_realm /*client_realm*/, krb5_const_realm /*server_realm*/, krb5_realm */*realms*/, unsigned int /*num_realms*/, int */*bad_realm*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_check_transited_realms ( krb5_context /*context*/, const char *const */*realms*/, unsigned int /*num_realms*/, int */*bad_realm*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_checksum_disable ( krb5_context /*context*/, krb5_cksumtype /*type*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_checksum_free ( krb5_context /*context*/, krb5_checksum */*cksum*/); KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_checksum_is_collision_proof ( krb5_context /*context*/, krb5_cksumtype /*type*/); KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_checksum_is_keyed ( krb5_context /*context*/, krb5_cksumtype /*type*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_checksumsize ( krb5_context /*context*/, krb5_cksumtype /*type*/, size_t */*size*/); /** * Return the coresponding encryption type for a checksum type. * * @param context Kerberos context * @param ctype The checksum type to get the result enctype for * @param etype The returned encryption, when the matching etype is * not found, etype is set to ETYPE_NULL. * * @return Return an error code for an failure or 0 on success. * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cksumtype_to_enctype ( krb5_context /*context*/, krb5_cksumtype /*ctype*/, krb5_enctype */*etype*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_cksumtype_valid ( krb5_context /*context*/, krb5_cksumtype /*ctype*/); /** * Clears the error message from the Kerberos 5 context. * * @param context The Kerberos 5 context to clear * * @ingroup krb5_error */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_clear_error_message (krb5_context /*context*/); /** * Clear the error message returned by krb5_get_error_string(). * * Deprecated: use krb5_clear_error_message() * * @param context Kerberos context * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_clear_error_string (krb5_context /*context*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_closelog ( krb5_context /*context*/, krb5_log_facility */*fac*/); /** * Return TRUE if `mcreds' and `creds' are equal (`whichfields' * determines what equal means). * * * The following flags, set in whichfields affects the comparison: * - KRB5_TC_MATCH_SRV_NAMEONLY Consider all realms equal when comparing the service principal. * - KRB5_TC_MATCH_KEYTYPE Compare enctypes. * - KRB5_TC_MATCH_FLAGS_EXACT Make sure that the ticket flags are identical. * - KRB5_TC_MATCH_FLAGS Make sure that all ticket flags set in mcreds are also present in creds . * - KRB5_TC_MATCH_TIMES_EXACT Compares the ticket times exactly. * - KRB5_TC_MATCH_TIMES Compares only the expiration times of the creds. * - KRB5_TC_MATCH_AUTHDATA Compares the authdata fields. * - KRB5_TC_MATCH_2ND_TKT Compares the second tickets (used by user-to-user authentication). * - KRB5_TC_MATCH_IS_SKEY Compares the existance of the second ticket. * * @param context Kerberos 5 context. * @param whichfields which fields to compare. * @param mcreds cred to compare with. * @param creds cred to compare with. * * @return return TRUE if mcred and creds are equal, FALSE if not. * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_compare_creds ( krb5_context /*context*/, krb5_flags /*whichfields*/, const krb5_creds * /*mcreds*/, const krb5_creds * /*creds*/); /** * Free configuration file section, the result of * krb5_config_parse_file() and krb5_config_parse_file_multi(). * * @param context A Kerberos 5 context * @param s the configuration section to free * * @return returns 0 on successes, otherwise an error code, see * krb5_get_error_message() * * @ingroup krb5_support */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_config_file_free ( krb5_context /*context*/, krb5_config_section */*s*/); /** * Free the resulting strings from krb5_config-get_strings() and * krb5_config_vget_strings(). * * @param strings strings to free * * @ingroup krb5_support */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_config_free_strings (char **/*strings*/); /** * Like krb5_config_get_bool() but with a va_list list of * configuration selection. * * Configuration value to a boolean value, where yes/true and any * non-zero number means TRUE and other value is FALSE. * * @param context A Kerberos 5 context. * @param c a configuration section, or NULL to use the section from context * @param ... a list of names, terminated with NULL. * * @return TRUE or FALSE * * @ingroup krb5_support */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_config_get_bool ( krb5_context /*context*/, const krb5_config_section */*c*/, ...); /** * krb5_config_get_bool_default() will convert the configuration * option value to a boolean value, where yes/true and any non-zero * number means TRUE and other value is FALSE. * * @param context A Kerberos 5 context. * @param c a configuration section, or NULL to use the section from context * @param def_value the default value to return if no configuration * found in the database. * @param ... a list of names, terminated with NULL. * * @return TRUE or FALSE * * @ingroup krb5_support */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_config_get_bool_default ( krb5_context /*context*/, const krb5_config_section */*c*/, krb5_boolean /*def_value*/, ...); KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_config_get_int ( krb5_context /*context*/, const krb5_config_section */*c*/, ...); KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_config_get_int_default ( krb5_context /*context*/, const krb5_config_section */*c*/, int /*def_value*/, ...); /** * Get a list of configuration binding list for more processing * * @param context A Kerberos 5 context. * @param c a configuration section, or NULL to use the section from context * @param ... a list of names, terminated with NULL. * * @return NULL if configuration list is not found, a list otherwise * * @ingroup krb5_support */ KRB5_LIB_FUNCTION const krb5_config_binding * KRB5_LIB_CALL krb5_config_get_list ( krb5_context /*context*/, const krb5_config_section */*c*/, ...); /** * Returns a "const char *" to a string in the configuration database. * The string may not be valid after a reload of the configuration * database so a caller should make a local copy if it needs to keep * the string. * * @param context A Kerberos 5 context. * @param c a configuration section, or NULL to use the section from context * @param ... a list of names, terminated with NULL. * * @return NULL if configuration string not found, a string otherwise * * @ingroup krb5_support */ KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL krb5_config_get_string ( krb5_context /*context*/, const krb5_config_section */*c*/, ...); /** * Like krb5_config_get_string(), but instead of returning NULL, * instead return a default value. * * @param context A Kerberos 5 context. * @param c a configuration section, or NULL to use the section from context * @param def_value the default value to return if no configuration * found in the database. * @param ... a list of names, terminated with NULL. * * @return a configuration string * * @ingroup krb5_support */ KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL krb5_config_get_string_default ( krb5_context /*context*/, const krb5_config_section */*c*/, const char */*def_value*/, ...); /** * Get a list of configuration strings, free the result with * krb5_config_free_strings(). * * @param context A Kerberos 5 context. * @param c a configuration section, or NULL to use the section from context * @param ... a list of names, terminated with NULL. * * @return TRUE or FALSE * * @ingroup krb5_support */ KRB5_LIB_FUNCTION char** KRB5_LIB_CALL krb5_config_get_strings ( krb5_context /*context*/, const krb5_config_section */*c*/, ...); /** * Get the time from the configuration file using a relative time, for example: 1h30s * * @param context A Kerberos 5 context. * @param c a configuration section, or NULL to use the section from context * @param ... a list of names, terminated with NULL. * * @return parsed the time or -1 on error * * @ingroup krb5_support */ KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_config_get_time ( krb5_context /*context*/, const krb5_config_section */*c*/, ...); /** * Get the time from the configuration file using a relative time, for example: 1h30s * * @param context A Kerberos 5 context. * @param c a configuration section, or NULL to use the section from context * @param def_value the default value to return if no configuration * found in the database. * @param ... a list of names, terminated with NULL. * * @return parsed the time (or def_value on parse error) * * @ingroup krb5_support */ KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_config_get_time_default ( krb5_context /*context*/, const krb5_config_section */*c*/, int /*def_value*/, ...); /** * If the fname starts with "~/" parse configuration file in the * current users home directory. The behavior can be disabled and * enabled by calling krb5_set_home_dir_access(). */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_config_parse_file ( krb5_context /*context*/, const char */*fname*/, krb5_config_section **/*res*/); /** * Parse a configuration file and add the result into res. This * interface can be used to parse several configuration files into one * resulting krb5_config_section by calling it repeatably. * * @param context a Kerberos 5 context. * @param fname a file name to a Kerberos configuration file * @param res the returned result, must be free with krb5_free_config_files(). * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_support */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_config_parse_file_multi ( krb5_context /*context*/, const char */*fname*/, krb5_config_section **/*res*/); /** * Deprecated: configuration files are not strings * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_config_parse_string_multi ( krb5_context /*context*/, const char */*string*/, krb5_config_section **/*res*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * krb5_config_get_bool() will convert the configuration * option value to a boolean value, where yes/true and any non-zero * number means TRUE and other value is FALSE. * * @param context A Kerberos 5 context. * @param c a configuration section, or NULL to use the section from context * @param args a va_list of arguments * * @return TRUE or FALSE * * @ingroup krb5_support */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_config_vget_bool ( krb5_context /*context*/, const krb5_config_section */*c*/, va_list /*args*/); /** * Like krb5_config_get_bool_default() but with a va_list list of * configuration selection. * * Configuration value to a boolean value, where yes/true and any * non-zero number means TRUE and other value is FALSE. * * @param context A Kerberos 5 context. * @param c a configuration section, or NULL to use the section from context * @param def_value the default value to return if no configuration * found in the database. * @param args a va_list of arguments * * @return TRUE or FALSE * * @ingroup krb5_support */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_config_vget_bool_default ( krb5_context /*context*/, const krb5_config_section */*c*/, krb5_boolean /*def_value*/, va_list /*args*/); KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_config_vget_int ( krb5_context /*context*/, const krb5_config_section */*c*/, va_list /*args*/); KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_config_vget_int_default ( krb5_context /*context*/, const krb5_config_section */*c*/, int /*def_value*/, va_list /*args*/); /** * Get a list of configuration binding list for more processing * * @param context A Kerberos 5 context. * @param c a configuration section, or NULL to use the section from context * @param args a va_list of arguments * * @return NULL if configuration list is not found, a list otherwise * * @ingroup krb5_support */ KRB5_LIB_FUNCTION const krb5_config_binding * KRB5_LIB_CALL krb5_config_vget_list ( krb5_context /*context*/, const krb5_config_section */*c*/, va_list /*args*/); /** * Like krb5_config_get_string(), but uses a va_list instead of ... * * @param context A Kerberos 5 context. * @param c a configuration section, or NULL to use the section from context * @param args a va_list of arguments * * @return NULL if configuration string not found, a string otherwise * * @ingroup krb5_support */ KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL krb5_config_vget_string ( krb5_context /*context*/, const krb5_config_section */*c*/, va_list /*args*/); /** * Like krb5_config_vget_string(), but instead of returning NULL, * instead return a default value. * * @param context A Kerberos 5 context. * @param c a configuration section, or NULL to use the section from context * @param def_value the default value to return if no configuration * found in the database. * @param args a va_list of arguments * * @return a configuration string * * @ingroup krb5_support */ KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL krb5_config_vget_string_default ( krb5_context /*context*/, const krb5_config_section */*c*/, const char */*def_value*/, va_list /*args*/); /** * Get a list of configuration strings, free the result with * krb5_config_free_strings(). * * @param context A Kerberos 5 context. * @param c a configuration section, or NULL to use the section from context * @param args a va_list of arguments * * @return TRUE or FALSE * * @ingroup krb5_support */ KRB5_LIB_FUNCTION char ** KRB5_LIB_CALL krb5_config_vget_strings ( krb5_context /*context*/, const krb5_config_section */*c*/, va_list /*args*/); /** * Get the time from the configuration file using a relative time, for example: 1h30s * * @param context A Kerberos 5 context. * @param c a configuration section, or NULL to use the section from context * @param args a va_list of arguments * * @return parsed the time or -1 on error * * @ingroup krb5_support */ KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_config_vget_time ( krb5_context /*context*/, const krb5_config_section */*c*/, va_list /*args*/); /** * Get the time from the configuration file using a relative time. * * Like krb5_config_get_time_default() but with a va_list list of * configuration selection. * * @param context A Kerberos 5 context. * @param c a configuration section, or NULL to use the section from context * @param def_value the default value to return if no configuration * found in the database. * @param args a va_list of arguments * * @return parsed the time (or def_value on parse error) * * @ingroup krb5_support */ KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_config_vget_time_default ( krb5_context /*context*/, const krb5_config_section */*c*/, int /*def_value*/, va_list /*args*/); /** * krb5_copy_address copies the content of address * inaddr to outaddr. * * @param context a Keberos context * @param inaddr pointer to source address * @param outaddr pointer to destination address * * @return Return an error code or 0. * * @ingroup krb5_address */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_copy_address ( krb5_context /*context*/, const krb5_address */*inaddr*/, krb5_address */*outaddr*/); /** * krb5_copy_addresses copies the content of addresses * inaddr to outaddr. * * @param context a Keberos context * @param inaddr pointer to source addresses * @param outaddr pointer to destination addresses * * @return Return an error code or 0. * * @ingroup krb5_address */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_copy_addresses ( krb5_context /*context*/, const krb5_addresses */*inaddr*/, krb5_addresses */*outaddr*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_copy_checksum ( krb5_context /*context*/, const krb5_checksum */*old*/, krb5_checksum **/*new*/); /** * Make a copy for the Kerberos 5 context, the new krb5_context shoud * be freed with krb5_free_context(). * * @param context the Kerberos context to copy * @param out the copy of the Kerberos, set to NULL error. * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_copy_context ( krb5_context /*context*/, krb5_context */*out*/); /** * Copy krb5_creds. * * @param context Kerberos 5 context. * @param incred source credential * @param outcred destination credential, free with krb5_free_creds(). * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_copy_creds ( krb5_context /*context*/, const krb5_creds */*incred*/, krb5_creds **/*outcred*/); /** * Copy content of krb5_creds. * * @param context Kerberos 5 context. * @param incred source credential * @param c destination credential, free with krb5_free_cred_contents(). * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_copy_creds_contents ( krb5_context /*context*/, const krb5_creds */*incred*/, krb5_creds */*c*/); /** * Copy the data into a newly allocated krb5_data. * * @param context Kerberos 5 context. * @param indata the krb5_data data to copy * @param outdata new krb5_date to copy too. Free with krb5_free_data(). * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned. * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_copy_data ( krb5_context /*context*/, const krb5_data */*indata*/, krb5_data **/*outdata*/); /** * Copy the list of realms from `from' to `to'. * * @param context Kerberos 5 context. * @param from list of realms to copy from. * @param to list of realms to copy to, free list of krb5_free_host_realm(). * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_copy_host_realm ( krb5_context /*context*/, const krb5_realm */*from*/, krb5_realm **/*to*/); /** * Copy a keyblock, free the output keyblock with * krb5_free_keyblock(). * * @param context a Kerberos 5 context * @param inblock the key to copy * @param to the output key. * * @return 0 on success or a Kerberos 5 error code * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_copy_keyblock ( krb5_context /*context*/, const krb5_keyblock */*inblock*/, krb5_keyblock **/*to*/); /** * Copy a keyblock, free the output keyblock with * krb5_free_keyblock_contents(). * * @param context a Kerberos 5 context * @param inblock the key to copy * @param to the output key. * * @return 0 on success or a Kerberos 5 error code * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_copy_keyblock_contents ( krb5_context /*context*/, const krb5_keyblock */*inblock*/, krb5_keyblock */*to*/); /** * Copy a principal * * @param context A Kerberos context. * @param inprinc principal to copy * @param outprinc copied principal, free with krb5_free_principal() * * @return An krb5 error code, see krb5_get_error_message(). * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_copy_principal ( krb5_context /*context*/, krb5_const_principal /*inprinc*/, krb5_principal */*outprinc*/); /** * Copy ticket and content * * @param context a Kerberos 5 context * @param from ticket to copy * @param to new copy of ticket, free with krb5_free_ticket() * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_copy_ticket ( krb5_context /*context*/, const krb5_ticket */*from*/, krb5_ticket **/*to*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_create_checksum ( krb5_context /*context*/, krb5_crypto /*crypto*/, krb5_key_usage /*usage*/, int /*type*/, void */*data*/, size_t /*len*/, Checksum */*result*/); /** * Create a Kerberos message checksum. * * @param context Kerberos context * @param crypto Kerberos crypto context * @param usage Key usage for this buffer * @param data array of buffers to process * @param num_data length of array * @param type output data * * @return Return an error code or 0. * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_create_checksum_iov ( krb5_context /*context*/, krb5_crypto /*crypto*/, unsigned /*usage*/, krb5_crypto_iov */*data*/, unsigned int /*num_data*/, krb5_cksumtype */*type*/); /** * Returns the ticket flags for the credentials in creds. * See also krb5_ticket_get_flags(). * * @param creds credential to get ticket flags from * * @return ticket flags * * @ingroup krb5 */ KRB5_LIB_FUNCTION unsigned long KRB5_LIB_CALL krb5_creds_get_ticket_flags (krb5_creds */*creds*/); /** * Free a crypto context created by krb5_crypto_init(). * * @param context Kerberos context * @param crypto crypto context to free * * @return Return an error code or 0. * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_crypto_destroy ( krb5_context /*context*/, krb5_crypto /*crypto*/); /** * The FX-CF2 key derivation function, used in FAST and preauth framework. * * @param context Kerberos 5 context * @param crypto1 first key to combine * @param crypto2 second key to combine * @param pepper1 factor to combine with first key to garante uniqueness * @param pepper2 factor to combine with second key to garante uniqueness * @param enctype the encryption type of the resulting key * @param res allocated key, free with krb5_free_keyblock_contents() * * @return Return an error code or 0. * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_crypto_fx_cf2 ( krb5_context /*context*/, const krb5_crypto /*crypto1*/, const krb5_crypto /*crypto2*/, krb5_data */*pepper1*/, krb5_data */*pepper2*/, krb5_enctype /*enctype*/, krb5_keyblock */*res*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_crypto_get_checksum_type ( krb5_context /*context*/, krb5_crypto /*crypto*/, krb5_cksumtype */*type*/); /** * Return the blocksize used algorithm referenced by the crypto context * * @param context Kerberos context * @param crypto crypto context to query * @param blocksize the resulting blocksize * * @return Return an error code or 0. * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_crypto_getblocksize ( krb5_context /*context*/, krb5_crypto /*crypto*/, size_t */*blocksize*/); /** * Return the confounder size used by the crypto context * * @param context Kerberos context * @param crypto crypto context to query * @param confoundersize the returned confounder size * * @return Return an error code or 0. * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_crypto_getconfoundersize ( krb5_context /*context*/, krb5_crypto /*crypto*/, size_t */*confoundersize*/); /** * Return the encryption type used by the crypto context * * @param context Kerberos context * @param crypto crypto context to query * @param enctype the resulting encryption type * * @return Return an error code or 0. * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_crypto_getenctype ( krb5_context /*context*/, krb5_crypto /*crypto*/, krb5_enctype */*enctype*/); /** * Return the padding size used by the crypto context * * @param context Kerberos context * @param crypto crypto context to query * @param padsize the return padding size * * @return Return an error code or 0. * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_crypto_getpadsize ( krb5_context /*context*/, krb5_crypto /*crypto*/, size_t */*padsize*/); /** * Create a crypto context used for all encryption and signature * operation. The encryption type to use is taken from the key, but * can be overridden with the enctype parameter. This can be useful * for encryptions types which is compatiable (DES for example). * * To free the crypto context, use krb5_crypto_destroy(). * * @param context Kerberos context * @param key the key block information with all key data * @param etype the encryption type * @param crypto the resulting crypto context * * @return Return an error code or 0. * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_crypto_init ( krb5_context /*context*/, const krb5_keyblock */*key*/, krb5_enctype /*etype*/, krb5_crypto */*crypto*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_crypto_length ( krb5_context /*context*/, krb5_crypto /*crypto*/, int /*type*/, size_t */*len*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_crypto_length_iov ( krb5_context /*context*/, krb5_crypto /*crypto*/, krb5_crypto_iov */*data*/, unsigned int /*num_data*/); KRB5_LIB_FUNCTION size_t KRB5_LIB_CALL krb5_crypto_overhead ( krb5_context /*context*/, krb5_crypto /*crypto*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_crypto_prf ( krb5_context /*context*/, const krb5_crypto /*crypto*/, const krb5_data */*input*/, krb5_data */*output*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_crypto_prf_length ( krb5_context /*context*/, krb5_enctype /*type*/, size_t */*length*/); /** * Allocate data of and krb5_data. * * @param p krb5_data to allocate. * @param len size to allocate. * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned. * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_data_alloc ( krb5_data */*p*/, int /*len*/); /** * Compare to data. * * @param data1 krb5_data to compare * @param data2 krb5_data to compare * * @return return the same way as memcmp(), useful when sorting. * * @ingroup krb5 */ KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_data_cmp ( const krb5_data */*data1*/, const krb5_data */*data2*/); /** * Copy the data of len into the krb5_data. * * @param p krb5_data to copy into. * @param data data to copy.. * @param len new size. * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned. * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_data_copy ( krb5_data */*p*/, const void */*data*/, size_t /*len*/); /** * Compare to data not exposing timing information from the checksum data * * @param data1 krb5_data to compare * @param data2 krb5_data to compare * * @return returns zero for same data, otherwise non zero. * * @ingroup krb5 */ KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_data_ct_cmp ( const krb5_data */*data1*/, const krb5_data */*data2*/); /** * Free the content of krb5_data structure, its ok to free a zeroed * structure (with memset() or krb5_data_zero()). When done, the * structure will be zeroed. The same function is called * krb5_free_data_contents() in MIT Kerberos. * * @param p krb5_data to free. * * @ingroup krb5 */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_data_free (krb5_data */*p*/); /** * Grow (or shrink) the content of krb5_data to a new size. * * @param p krb5_data to free. * @param len new size. * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned. * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_data_realloc ( krb5_data */*p*/, int /*len*/); /** * Reset the (potentially uninitalized) krb5_data structure. * * @param p krb5_data to reset. * * @ingroup krb5 */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_data_zero (krb5_data */*p*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_decode_Authenticator ( krb5_context /*context*/, const void */*data*/, size_t /*length*/, Authenticator */*t*/, size_t */*len*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_decode_ETYPE_INFO ( krb5_context /*context*/, const void */*data*/, size_t /*length*/, ETYPE_INFO */*t*/, size_t */*len*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_decode_ETYPE_INFO2 ( krb5_context /*context*/, const void */*data*/, size_t /*length*/, ETYPE_INFO2 */*t*/, size_t */*len*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_decode_EncAPRepPart ( krb5_context /*context*/, const void */*data*/, size_t /*length*/, EncAPRepPart */*t*/, size_t */*len*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_decode_EncASRepPart ( krb5_context /*context*/, const void */*data*/, size_t /*length*/, EncASRepPart */*t*/, size_t */*len*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_decode_EncKrbCredPart ( krb5_context /*context*/, const void */*data*/, size_t /*length*/, EncKrbCredPart */*t*/, size_t */*len*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_decode_EncTGSRepPart ( krb5_context /*context*/, const void */*data*/, size_t /*length*/, EncTGSRepPart */*t*/, size_t */*len*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_decode_EncTicketPart ( krb5_context /*context*/, const void */*data*/, size_t /*length*/, EncTicketPart */*t*/, size_t */*len*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_decode_ap_req ( krb5_context /*context*/, const krb5_data */*inbuf*/, krb5_ap_req */*ap_req*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_decrypt ( krb5_context /*context*/, krb5_crypto /*crypto*/, unsigned /*usage*/, void */*data*/, size_t /*len*/, krb5_data */*result*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_decrypt_EncryptedData ( krb5_context /*context*/, krb5_crypto /*crypto*/, unsigned /*usage*/, const EncryptedData */*e*/, krb5_data */*result*/); /** * Inline decrypt a Kerberos message. * * @param context Kerberos context * @param crypto Kerberos crypto context * @param usage Key usage for this buffer * @param data array of buffers to process * @param num_data length of array * @param ivec initial cbc/cts vector * * @return Return an error code or 0. * @ingroup krb5_crypto * * 1. KRB5_CRYPTO_TYPE_HEADER * 2. one KRB5_CRYPTO_TYPE_DATA and array [0,...] of KRB5_CRYPTO_TYPE_SIGN_ONLY in * any order, however the receiver have to aware of the * order. KRB5_CRYPTO_TYPE_SIGN_ONLY is commonly used unencrypoted * protocol headers and trailers. The output data will be of same * size as the input data or shorter. */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_decrypt_iov_ivec ( krb5_context /*context*/, krb5_crypto /*crypto*/, unsigned /*usage*/, krb5_crypto_iov */*data*/, unsigned int /*num_data*/, void */*ivec*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_decrypt_ivec ( krb5_context /*context*/, krb5_crypto /*crypto*/, unsigned /*usage*/, void */*data*/, size_t /*len*/, krb5_data */*result*/, void */*ivec*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_decrypt_ticket ( krb5_context /*context*/, Ticket */*ticket*/, krb5_keyblock */*key*/, EncTicketPart */*out*/, krb5_flags /*flags*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_derive_key ( krb5_context /*context*/, const krb5_keyblock */*key*/, krb5_enctype /*etype*/, const void */*constant*/, size_t /*constant_len*/, krb5_keyblock **/*derived_key*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_alloc ( krb5_context /*context*/, krb5_digest */*digest*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_digest_free (krb5_digest /*digest*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_get_client_binding ( krb5_context /*context*/, krb5_digest /*digest*/, char **/*type*/, char **/*binding*/); KRB5_LIB_FUNCTION const char * KRB5_LIB_CALL krb5_digest_get_identifier ( krb5_context /*context*/, krb5_digest /*digest*/); KRB5_LIB_FUNCTION const char * KRB5_LIB_CALL krb5_digest_get_opaque ( krb5_context /*context*/, krb5_digest /*digest*/); KRB5_LIB_FUNCTION const char * KRB5_LIB_CALL krb5_digest_get_rsp ( krb5_context /*context*/, krb5_digest /*digest*/); KRB5_LIB_FUNCTION const char * KRB5_LIB_CALL krb5_digest_get_server_nonce ( krb5_context /*context*/, krb5_digest /*digest*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_get_session_key ( krb5_context /*context*/, krb5_digest /*digest*/, krb5_data */*data*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_get_tickets ( krb5_context /*context*/, krb5_digest /*digest*/, Ticket **/*tickets*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_init_request ( krb5_context /*context*/, krb5_digest /*digest*/, krb5_realm /*realm*/, krb5_ccache /*ccache*/); /** * Get the supported/allowed mechanism for this principal. * * @param context A Keberos context. * @param realm The realm of the KDC. * @param ccache The credential cache to use when talking to the KDC. * @param flags The supported mechanism. * * @return Return an error code or 0. * * @ingroup krb5_digest */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_probe ( krb5_context /*context*/, krb5_realm /*realm*/, krb5_ccache /*ccache*/, unsigned */*flags*/); KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_digest_rep_get_status ( krb5_context /*context*/, krb5_digest /*digest*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_request ( krb5_context /*context*/, krb5_digest /*digest*/, krb5_realm /*realm*/, krb5_ccache /*ccache*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_set_authentication_user ( krb5_context /*context*/, krb5_digest /*digest*/, krb5_principal /*authentication_user*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_set_authid ( krb5_context /*context*/, krb5_digest /*digest*/, const char */*authid*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_set_client_nonce ( krb5_context /*context*/, krb5_digest /*digest*/, const char */*nonce*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_set_digest ( krb5_context /*context*/, krb5_digest /*digest*/, const char */*dgst*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_set_hostname ( krb5_context /*context*/, krb5_digest /*digest*/, const char */*hostname*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_set_identifier ( krb5_context /*context*/, krb5_digest /*digest*/, const char */*id*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_set_method ( krb5_context /*context*/, krb5_digest /*digest*/, const char */*method*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_set_nonceCount ( krb5_context /*context*/, krb5_digest /*digest*/, const char */*nonce_count*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_set_opaque ( krb5_context /*context*/, krb5_digest /*digest*/, const char */*opaque*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_set_qop ( krb5_context /*context*/, krb5_digest /*digest*/, const char */*qop*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_set_realm ( krb5_context /*context*/, krb5_digest /*digest*/, const char */*realm*/); KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_digest_set_responseData ( krb5_context /*context*/, krb5_digest /*digest*/, const char */*response*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_set_server_cb ( krb5_context /*context*/, krb5_digest /*digest*/, const char */*type*/, const char */*binding*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_set_server_nonce ( krb5_context /*context*/, krb5_digest /*digest*/, const char */*nonce*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_set_type ( krb5_context /*context*/, krb5_digest /*digest*/, const char */*type*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_set_uri ( krb5_context /*context*/, krb5_digest /*digest*/, const char */*uri*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_digest_set_username ( krb5_context /*context*/, krb5_digest /*digest*/, const char */*username*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_domain_x500_decode ( krb5_context /*context*/, krb5_data /*tr*/, char ***/*realms*/, unsigned int */*num_realms*/, const char */*client_realm*/, const char */*server_realm*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_domain_x500_encode ( char **/*realms*/, unsigned int /*num_realms*/, krb5_data */*encoding*/); /** * Convert the getaddrinfo() error code to a Kerberos et error code. * * @param eai_errno contains the error code from getaddrinfo(). * @param system_error should have the value of errno after the failed getaddrinfo(). * * @return Kerberos error code representing the EAI errors. * * @ingroup krb5_error */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_eai_to_heim_errno ( int /*eai_errno*/, int /*system_error*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_encode_Authenticator ( krb5_context /*context*/, void */*data*/, size_t /*length*/, Authenticator */*t*/, size_t */*len*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_encode_ETYPE_INFO ( krb5_context /*context*/, void */*data*/, size_t /*length*/, ETYPE_INFO */*t*/, size_t */*len*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_encode_ETYPE_INFO2 ( krb5_context /*context*/, void */*data*/, size_t /*length*/, ETYPE_INFO2 */*t*/, size_t */*len*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_encode_EncAPRepPart ( krb5_context /*context*/, void */*data*/, size_t /*length*/, EncAPRepPart */*t*/, size_t */*len*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_encode_EncASRepPart ( krb5_context /*context*/, void */*data*/, size_t /*length*/, EncASRepPart */*t*/, size_t */*len*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_encode_EncKrbCredPart ( krb5_context /*context*/, void */*data*/, size_t /*length*/, EncKrbCredPart */*t*/, size_t */*len*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_encode_EncTGSRepPart ( krb5_context /*context*/, void */*data*/, size_t /*length*/, EncTGSRepPart */*t*/, size_t */*len*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_encode_EncTicketPart ( krb5_context /*context*/, void */*data*/, size_t /*length*/, EncTicketPart */*t*/, size_t */*len*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_encrypt ( krb5_context /*context*/, krb5_crypto /*crypto*/, unsigned /*usage*/, const void */*data*/, size_t /*len*/, krb5_data */*result*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_encrypt_EncryptedData ( krb5_context /*context*/, krb5_crypto /*crypto*/, unsigned /*usage*/, void */*data*/, size_t /*len*/, int /*kvno*/, EncryptedData */*result*/); /** * Inline encrypt a kerberos message * * @param context Kerberos context * @param crypto Kerberos crypto context * @param usage Key usage for this buffer * @param data array of buffers to process * @param num_data length of array * @param ivec initial cbc/cts vector * * @return Return an error code or 0. * @ingroup krb5_crypto * * Kerberos encrypted data look like this: * * 1. KRB5_CRYPTO_TYPE_HEADER * 2. array [1,...] KRB5_CRYPTO_TYPE_DATA and array [0,...] * KRB5_CRYPTO_TYPE_SIGN_ONLY in any order, however the receiver * have to aware of the order. KRB5_CRYPTO_TYPE_SIGN_ONLY is * commonly used headers and trailers. * 3. KRB5_CRYPTO_TYPE_PADDING, at least on padsize long if padsize > 1 * 4. KRB5_CRYPTO_TYPE_TRAILER */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_encrypt_iov_ivec ( krb5_context /*context*/, krb5_crypto /*crypto*/, unsigned /*usage*/, krb5_crypto_iov */*data*/, int /*num_data*/, void */*ivec*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_encrypt_ivec ( krb5_context /*context*/, krb5_crypto /*crypto*/, unsigned /*usage*/, const void */*data*/, size_t /*len*/, krb5_data */*result*/, void */*ivec*/); /** * Disable encryption type * * @param context Kerberos 5 context * @param enctype encryption type to disable * * @return Return an error code or 0. * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_enctype_disable ( krb5_context /*context*/, krb5_enctype /*enctype*/); /** * Enable encryption type * * @param context Kerberos 5 context * @param enctype encryption type to enable * * @return Return an error code or 0. * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_enctype_enable ( krb5_context /*context*/, krb5_enctype /*enctype*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_enctype_keybits ( krb5_context /*context*/, krb5_enctype /*type*/, size_t */*keybits*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_enctype_keysize ( krb5_context /*context*/, krb5_enctype /*type*/, size_t */*keysize*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_enctype_to_keytype ( krb5_context /*context*/, krb5_enctype /*etype*/, krb5_keytype */*keytype*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_enctype_to_string ( krb5_context /*context*/, krb5_enctype /*etype*/, char **/*string*/); /** * Check if a enctype is valid, return 0 if it is. * * @param context Kerberos context * @param etype enctype to check if its valid or not * * @return Return an error code for an failure or 0 on success (enctype valid). * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_enctype_valid ( krb5_context /*context*/, krb5_enctype /*etype*/); /** * Deprecated: keytypes doesn't exists, they are really enctypes. * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_enctypes_compatible_keys ( krb5_context /*context*/, krb5_enctype /*etype1*/, krb5_enctype /*etype2*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); krb5_error_code krb5_enomem (krb5_context /*context*/); /** * Log a warning to the log, default stderr, include bthe error from * the last failure and then exit. * * @param context A Kerberos 5 context * @param eval the exit code to exit with * @param code error code of the last error * @param fmt message to print * * @ingroup krb5_error */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_err ( krb5_context /*context*/, int /*eval*/, krb5_error_code /*code*/, const char */*fmt*/, ...) __attribute__ ((__noreturn__, __format__ (__printf__, 4, 5))); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_error_from_rd_error ( krb5_context /*context*/, const krb5_error */*error*/, const krb5_creds */*creds*/); /** * Log a warning to the log, default stderr, and then exit. * * @param context A Kerberos 5 context * @param eval the exit code to exit with * @param fmt message to print * * @ingroup krb5_error */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_errx ( krb5_context /*context*/, int /*eval*/, const char */*fmt*/, ...) __attribute__ ((__noreturn__, __format__ (__printf__, 3, 4))); /** * krb5_expand_hostname() tries to make orig_hostname into a more * canonical one in the newly allocated space returned in * new_hostname. * @param context a Keberos context * @param orig_hostname hostname to canonicalise. * @param new_hostname output hostname, caller must free hostname with * krb5_xfree(). * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_support */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_expand_hostname ( krb5_context /*context*/, const char */*orig_hostname*/, char **/*new_hostname*/); /** * krb5_expand_hostname_realms() expands orig_hostname to a name we * believe to be a hostname in newly allocated space in new_hostname * and return the realms new_hostname is believed to belong to in * realms. * * @param context a Keberos context * @param orig_hostname hostname to canonicalise. * @param new_hostname output hostname, caller must free hostname with * krb5_xfree(). * @param realms output possible realms, is an array that is terminated * with NULL. Caller must free with krb5_free_host_realm(). * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_support */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_expand_hostname_realms ( krb5_context /*context*/, const char */*orig_hostname*/, char **/*new_hostname*/, char ***/*realms*/); KRB5_LIB_FUNCTION PA_DATA * KRB5_LIB_CALL krb5_find_padata ( PA_DATA */*val*/, unsigned /*len*/, int /*type*/, int */*idx*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_format_time ( krb5_context /*context*/, time_t /*t*/, char */*s*/, size_t /*len*/, krb5_boolean /*include_time*/); /** * krb5_free_address frees the data stored in the address that is * alloced with any of the krb5_address functions. * * @param context a Keberos context * @param address addresss to be freed. * * @return Return an error code or 0. * * @ingroup krb5_address */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_free_address ( krb5_context /*context*/, krb5_address */*address*/); /** * krb5_free_addresses frees the data stored in the address that is * alloced with any of the krb5_address functions. * * @param context a Keberos context * @param addresses addressses to be freed. * * @return Return an error code or 0. * * @ingroup krb5_address */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_free_addresses ( krb5_context /*context*/, krb5_addresses */*addresses*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_free_ap_rep_enc_part ( krb5_context /*context*/, krb5_ap_rep_enc_part */*val*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_free_authenticator ( krb5_context /*context*/, krb5_authenticator */*authenticator*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_free_checksum ( krb5_context /*context*/, krb5_checksum */*cksum*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_free_checksum_contents ( krb5_context /*context*/, krb5_checksum */*cksum*/); /** * Free a list of configuration files. * * @param filenames list, terminated with a NULL pointer, to be * freed. NULL is an valid argument. * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_free_config_files (char **/*filenames*/); /** * Frees the krb5_context allocated by krb5_init_context(). * * @param context context to be freed. * * @ingroup krb5 */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_free_context (krb5_context /*context*/); /** * Free content of krb5_creds. * * @param context Kerberos 5 context. * @param c krb5_creds to free. * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_free_cred_contents ( krb5_context /*context*/, krb5_creds */*c*/); /** * Free krb5_creds. * * @param context Kerberos 5 context. * @param c krb5_creds to free. * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_free_creds ( krb5_context /*context*/, krb5_creds */*c*/); /** * Deprecated: use krb5_free_cred_contents() * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_free_creds_contents ( krb5_context /*context*/, krb5_creds */*c*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Free krb5_data (and its content). * * @param context Kerberos 5 context. * @param p krb5_data to free. * * @ingroup krb5 */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_free_data ( krb5_context /*context*/, krb5_data */*p*/); /** * Same as krb5_data_free(). MIT compat. * * Deprecated: use krb5_data_free(). * * @param context Kerberos 5 context. * @param data krb5_data to free. * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_free_data_contents ( krb5_context /*context*/, krb5_data */*data*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_free_default_realm ( krb5_context /*context*/, krb5_realm /*realm*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_free_error ( krb5_context /*context*/, krb5_error */*error*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_free_error_contents ( krb5_context /*context*/, krb5_error */*error*/); /** * Free the error message returned by krb5_get_error_message(). * * @param context Kerberos context * @param msg error message to free, returned byg * krb5_get_error_message(). * * @ingroup krb5_error */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_free_error_message ( krb5_context /*context*/, const char */*msg*/); /** * Free the error message returned by krb5_get_error_string(). * * Deprecated: use krb5_free_error_message() * * @param context Kerberos context * @param str error message to free * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_free_error_string ( krb5_context /*context*/, char */*str*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Free all memory allocated by `realmlist' * * @param context A Kerberos 5 context. * @param realmlist realmlist to free, NULL is ok * * @return a Kerberos error code, always 0. * * @ingroup krb5_support */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_free_host_realm ( krb5_context /*context*/, krb5_realm */*realmlist*/); /** * Variable containing the FILE based credential cache implemention. * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_free_kdc_rep ( krb5_context /*context*/, krb5_kdc_rep */*rep*/); /** * Free a keyblock, also zero out the content of the keyblock, uses * krb5_free_keyblock_contents() to free the content. * * @param context a Kerberos 5 context * @param keyblock keyblock to free, NULL is valid argument * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_free_keyblock ( krb5_context /*context*/, krb5_keyblock */*keyblock*/); /** * Free a keyblock's content, also zero out the content of the keyblock. * * @param context a Kerberos 5 context * @param keyblock keyblock content to free, NULL is valid argument * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_free_keyblock_contents ( krb5_context /*context*/, krb5_keyblock */*keyblock*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_free_krbhst ( krb5_context /*context*/, char **/*hostlist*/); /** * Free a name canonicalization rule iterator. */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_free_name_canon_iterator ( krb5_context /*context*/, krb5_name_canon_iterator /*iter*/); /** * Frees a Kerberos principal allocated by the library with * krb5_parse_name(), krb5_make_principal() or any other related * principal functions. * * @param context A Kerberos context. * @param p a principal to free. * * @return An krb5 error code, see krb5_get_error_message(). * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_free_principal ( krb5_context /*context*/, krb5_principal /*p*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_free_salt ( krb5_context /*context*/, krb5_salt /*salt*/); /** * Free ticket and content * * @param context a Kerberos 5 context * @param ticket ticket to free * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_free_ticket ( krb5_context /*context*/, krb5_ticket */*ticket*/); /** * Deprecated: use krb5_xfree(). * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_free_unparsed_name ( krb5_context /*context*/, char */*str*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Forward credentials for client to host hostname , making them * forwardable if forwardable, and returning the blob of data to sent * in out_data. If hostname == NULL, pick it from server. * * @param context A kerberos 5 context. * @param auth_context the auth context with the key to encrypt the out_data. * @param hostname the host to forward the tickets too. * @param client the client to delegate from. * @param server the server to delegate the credential too. * @param ccache credential cache to use. * @param forwardable make the forwarded ticket forwabledable. * @param out_data the resulting credential. * * @return Return an error code or 0. * * @ingroup krb5_credential */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_fwd_tgt_creds ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, const char */*hostname*/, krb5_principal /*client*/, krb5_principal /*server*/, krb5_ccache /*ccache*/, int /*forwardable*/, krb5_data */*out_data*/); /** * Fill buffer buf with len bytes of PRNG randomness that is ok to use * for key generation, padding and public diclosing the randomness w/o * disclosing the randomness source. * * This function can fail, and callers must check the return value. * * @param buf a buffer to fill with randomness * @param len length of memory that buf points to. * * @return return 0 on success or HEIM_ERR_RANDOM_OFFLINE if the * funcation failed to initialize the randomness source. * * @ingroup krb5_crypto */ HEIMDAL_WARN_UNUSED_RESULT_ATTRIBUTE KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_generate_random ( void */*buf*/, size_t /*len*/); /** * Fill buffer buf with len bytes of PRNG randomness that is ok to use * for key generation, padding and public diclosing the randomness w/o * disclosing the randomness source. * * This function can NOT fail, instead it will abort() and program will crash. * * If this function is called after a successful krb5_init_context(), * the chance of it failing is low due to that krb5_init_context() * pulls out some random, and quite commonly the randomness sources * will not fail once it have started to produce good output, * /dev/urandom behavies that way. * * @param buf a buffer to fill with randomness * @param len length of memory that buf points to. * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_generate_random_block ( void */*buf*/, size_t /*len*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_generate_random_keyblock ( krb5_context /*context*/, krb5_enctype /*type*/, krb5_keyblock */*key*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_generate_seq_number ( krb5_context /*context*/, const krb5_keyblock */*key*/, uint32_t */*seqno*/); /** * Deprecated: use krb5_generate_subkey_extended() * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_generate_subkey ( krb5_context /*context*/, const krb5_keyblock */*key*/, krb5_keyblock **/*subkey*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Generate subkey, from keyblock * * @param context kerberos context * @param key session key * @param etype encryption type of subkey, if ETYPE_NULL, use key's enctype * @param subkey returned new, free with krb5_free_keyblock(). * * @return 0 on success or a Kerberos 5 error code * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_generate_subkey_extended ( krb5_context /*context*/, const krb5_keyblock */*key*/, krb5_enctype /*etype*/, krb5_keyblock **/*subkey*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_all_client_addrs ( krb5_context /*context*/, krb5_addresses */*res*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_all_server_addrs ( krb5_context /*context*/, krb5_addresses */*res*/); /** * Deprecated: use krb5_get_credentials_with_flags(). * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_cred_from_kdc ( krb5_context /*context*/, krb5_ccache /*ccache*/, krb5_creds */*in_creds*/, krb5_creds **/*out_creds*/, krb5_creds ***/*ret_tgts*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Deprecated: use krb5_get_credentials_with_flags(). * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_cred_from_kdc_opt ( krb5_context /*context*/, krb5_ccache /*ccache*/, krb5_creds */*in_creds*/, krb5_creds **/*out_creds*/, krb5_creds ***/*ret_tgts*/, krb5_flags /*flags*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_credentials ( krb5_context /*context*/, krb5_flags /*options*/, krb5_ccache /*ccache*/, krb5_creds */*in_creds*/, krb5_creds **/*out_creds*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_credentials_with_flags ( krb5_context /*context*/, krb5_flags /*options*/, krb5_kdc_flags /*flags*/, krb5_ccache /*ccache*/, krb5_creds */*in_creds*/, krb5_creds **/*out_creds*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_creds ( krb5_context /*context*/, krb5_get_creds_opt /*opt*/, krb5_ccache /*ccache*/, krb5_const_principal /*inprinc*/, krb5_creds **/*out_creds*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_get_creds_opt_add_options ( krb5_context /*context*/, krb5_get_creds_opt /*opt*/, krb5_flags /*options*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_creds_opt_alloc ( krb5_context /*context*/, krb5_get_creds_opt */*opt*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_get_creds_opt_free ( krb5_context /*context*/, krb5_get_creds_opt /*opt*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_get_creds_opt_set_enctype ( krb5_context /*context*/, krb5_get_creds_opt /*opt*/, krb5_enctype /*enctype*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_creds_opt_set_impersonate ( krb5_context /*context*/, krb5_get_creds_opt /*opt*/, krb5_const_principal /*self*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_get_creds_opt_set_options ( krb5_context /*context*/, krb5_get_creds_opt /*opt*/, krb5_flags /*options*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_creds_opt_set_ticket ( krb5_context /*context*/, krb5_get_creds_opt /*opt*/, const Ticket */*ticket*/); /** * Get the global configuration list. * * @param pfilenames return array of filenames, should be freed with krb5_free_config_files(). * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_default_config_files (char ***/*pfilenames*/); /** * Get the default encryption types that will be use in communcation * with the KDC, clients and servers. * * @param context Kerberos 5 context. * @param pdu_type request type (AS, TGS or none) * @param etypes Encryption types, array terminated with * ETYPE_NULL(0), caller should free array with krb5_xfree(): * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_default_in_tkt_etypes ( krb5_context /*context*/, krb5_pdu /*pdu_type*/, krb5_enctype **/*etypes*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_default_principal ( krb5_context /*context*/, krb5_principal */*princ*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_default_realm ( krb5_context /*context*/, krb5_realm */*realm*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_default_realms ( krb5_context /*context*/, krb5_realm **/*realms*/); /** * Get if the library uses DNS to canonicalize hostnames. * * @param context Kerberos 5 context. * * @return return non zero if the library uses DNS to canonicalize hostnames. * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_get_dns_canonicalize_hostname (krb5_context /*context*/); /** * Return the error string for the error code. The caller must not * free the string. * * This function is deprecated since its not threadsafe. * * @param context Kerberos 5 context. * @param code Kerberos error code. * * @return the error message matching code * * @ingroup krb5 */ KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL krb5_get_err_text ( krb5_context /*context*/, krb5_error_code /*code*/) KRB5_DEPRECATED_FUNCTION("Use krb5_get_error_message instead"); /** * Return the error message for `code' in context. On memory * allocation error the function returns NULL. * * @param context Kerberos 5 context * @param code Error code related to the error * * @return an error string, needs to be freed with * krb5_free_error_message(). The functions return NULL on error. * * @ingroup krb5_error */ KRB5_LIB_FUNCTION const char * KRB5_LIB_CALL krb5_get_error_message ( krb5_context /*context*/, krb5_error_code /*code*/); /** * Return the error message in context. On error or no error string, * the function returns NULL. * * @param context Kerberos 5 context * * @return an error string, needs to be freed with * krb5_free_error_message(). The functions return NULL on error. * * @ingroup krb5_error */ KRB5_LIB_FUNCTION char * KRB5_LIB_CALL krb5_get_error_string (krb5_context /*context*/) KRB5_DEPRECATED_FUNCTION("Use krb5_get_error_message instead"); /** * Get extra address to the address list that the library will add to * the client's address list when communicating with the KDC. * * @param context Kerberos 5 context. * @param addresses addreses to set * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_extra_addresses ( krb5_context /*context*/, krb5_addresses */*addresses*/); /** * Get version of fcache that the library should use. * * @param context Kerberos 5 context. * @param version version number. * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_fcache_version ( krb5_context /*context*/, int */*version*/); /** * Gets tickets forwarded to hostname. If the tickets that are * forwarded are address-less, the forwarded tickets will also be * address-less. * * If the ticket have any address, hostname will be used for figure * out the address to forward the ticket too. This since this might * use DNS, its insecure and also doesn't represent configured all * addresses of the host. For example, the host might have two * adresses, one IPv4 and one IPv6 address where the later is not * published in DNS. This IPv6 address might be used communications * and thus the resulting ticket useless. * * @param context A kerberos 5 context. * @param auth_context the auth context with the key to encrypt the out_data. * @param ccache credential cache to use * @param flags the flags to control the resulting ticket flags * @param hostname the host to forward the tickets too. * @param in_creds the in client and server ticket names. The client * and server components forwarded to the remote host. * @param out_data the resulting credential. * * @return Return an error code or 0. * * @ingroup krb5_credential */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_forwarded_creds ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_ccache /*ccache*/, krb5_flags /*flags*/, const char */*hostname*/, krb5_creds */*in_creds*/, krb5_data */*out_data*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_host_realm ( krb5_context /*context*/, const char */*targethost*/, krb5_realm **/*realms*/); /** * Get extra addresses to ignore when fetching addresses from the * underlaying operating system. * * @param context Kerberos 5 context. * @param addresses list addreses ignored * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_ignore_addresses ( krb5_context /*context*/, krb5_addresses */*addresses*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_in_cred ( krb5_context /*context*/, krb5_flags /*options*/, const krb5_addresses */*addrs*/, const krb5_enctype */*etypes*/, const krb5_preauthtype */*ptypes*/, const krb5_preauthdata */*preauth*/, krb5_key_proc /*key_proc*/, krb5_const_pointer /*keyseed*/, krb5_decrypt_proc /*decrypt_proc*/, krb5_const_pointer /*decryptarg*/, krb5_creds */*creds*/, krb5_kdc_rep */*ret_as_reply*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_in_tkt ( krb5_context /*context*/, krb5_flags /*options*/, const krb5_addresses */*addrs*/, const krb5_enctype */*etypes*/, const krb5_preauthtype */*ptypes*/, krb5_key_proc /*key_proc*/, krb5_const_pointer /*keyseed*/, krb5_decrypt_proc /*decrypt_proc*/, krb5_const_pointer /*decryptarg*/, krb5_creds */*creds*/, krb5_ccache /*ccache*/, krb5_kdc_rep */*ret_as_reply*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Deprecated: use krb5_get_init_creds() and friends. * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_in_tkt_with_keytab ( krb5_context /*context*/, krb5_flags /*options*/, krb5_addresses */*addrs*/, const krb5_enctype */*etypes*/, const krb5_preauthtype */*pre_auth_types*/, krb5_keytab /*keytab*/, krb5_ccache /*ccache*/, krb5_creds */*creds*/, krb5_kdc_rep */*ret_as_reply*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Deprecated: use krb5_get_init_creds() and friends. * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_in_tkt_with_password ( krb5_context /*context*/, krb5_flags /*options*/, krb5_addresses */*addrs*/, const krb5_enctype */*etypes*/, const krb5_preauthtype */*pre_auth_types*/, const char */*password*/, krb5_ccache /*ccache*/, krb5_creds */*creds*/, krb5_kdc_rep */*ret_as_reply*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Deprecated: use krb5_get_init_creds() and friends. * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_in_tkt_with_skey ( krb5_context /*context*/, krb5_flags /*options*/, krb5_addresses */*addrs*/, const krb5_enctype */*etypes*/, const krb5_preauthtype */*pre_auth_types*/, const krb5_keyblock */*key*/, krb5_ccache /*ccache*/, krb5_creds */*creds*/, krb5_kdc_rep */*ret_as_reply*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Get new credentials using keyblock. * * @ingroup krb5_credential */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_init_creds_keyblock ( krb5_context /*context*/, krb5_creds */*creds*/, krb5_principal /*client*/, krb5_keyblock */*keyblock*/, krb5_deltat /*start_time*/, const char */*in_tkt_service*/, krb5_get_init_creds_opt */*options*/); /** * Get new credentials using keytab. * * @ingroup krb5_credential */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_init_creds_keytab ( krb5_context /*context*/, krb5_creds */*creds*/, krb5_principal /*client*/, krb5_keytab /*keytab*/, krb5_deltat /*start_time*/, const char */*in_tkt_service*/, krb5_get_init_creds_opt */*options*/); /** * Allocate a new krb5_get_init_creds_opt structure, free with * krb5_get_init_creds_opt_free(). * * @ingroup krb5_credential */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_init_creds_opt_alloc ( krb5_context /*context*/, krb5_get_init_creds_opt **/*opt*/); /** * Free krb5_get_init_creds_opt structure. * * @ingroup krb5_credential */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_get_init_creds_opt_free ( krb5_context /*context*/, krb5_get_init_creds_opt */*opt*/); /** * Deprecated: use the new krb5_init_creds_init() and * krb5_init_creds_get_error(). * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_init_creds_opt_get_error ( krb5_context /*context*/, krb5_get_init_creds_opt */*opt*/, KRB_ERROR **/*error*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Deprecated: use krb5_get_init_creds_opt_alloc(). * * The reason krb5_get_init_creds_opt_init() is deprecated is that * krb5_get_init_creds_opt is a static structure and for ABI reason it * can't grow, ie can't add new functionality. * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_get_init_creds_opt_init (krb5_get_init_creds_opt */*opt*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_get_init_creds_opt_set_address_list ( krb5_get_init_creds_opt */*opt*/, krb5_addresses */*addresses*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_init_creds_opt_set_addressless ( krb5_context /*context*/, krb5_get_init_creds_opt */*opt*/, krb5_boolean /*addressless*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_get_init_creds_opt_set_anonymous ( krb5_get_init_creds_opt */*opt*/, int /*anonymous*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_init_creds_opt_set_canonicalize ( krb5_context /*context*/, krb5_get_init_creds_opt */*opt*/, krb5_boolean /*req*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_get_init_creds_opt_set_change_password_prompt ( krb5_get_init_creds_opt */*opt*/, int /*change_password_prompt*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_get_init_creds_opt_set_default_flags ( krb5_context /*context*/, const char */*appname*/, krb5_const_realm /*realm*/, krb5_get_init_creds_opt */*opt*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_get_init_creds_opt_set_etype_list ( krb5_get_init_creds_opt */*opt*/, krb5_enctype */*etype_list*/, int /*etype_list_length*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_get_init_creds_opt_set_forwardable ( krb5_get_init_creds_opt */*opt*/, int /*forwardable*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_init_creds_opt_set_pa_password ( krb5_context /*context*/, krb5_get_init_creds_opt */*opt*/, const char */*password*/, krb5_s2k_proc /*key_proc*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_init_creds_opt_set_pac_request ( krb5_context /*context*/, krb5_get_init_creds_opt */*opt*/, krb5_boolean /*req_pac*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_init_creds_opt_set_pkinit ( krb5_context /*context*/, krb5_get_init_creds_opt */*opt*/, krb5_principal /*principal*/, const char */*user_id*/, const char */*x509_anchors*/, char * const * /*pool*/, char * const * /*pki_revoke*/, int /*flags*/, krb5_prompter_fct /*prompter*/, void */*prompter_data*/, char */*password*/); krb5_error_code KRB5_LIB_FUNCTION krb5_get_init_creds_opt_set_pkinit_user_certs ( krb5_context /*context*/, krb5_get_init_creds_opt */*opt*/, struct hx509_certs_data */*certs*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_get_init_creds_opt_set_preauth_list ( krb5_get_init_creds_opt */*opt*/, krb5_preauthtype */*preauth_list*/, int /*preauth_list_length*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_init_creds_opt_set_process_last_req ( krb5_context /*context*/, krb5_get_init_creds_opt */*opt*/, krb5_gic_process_last_req /*func*/, void */*ctx*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_get_init_creds_opt_set_proxiable ( krb5_get_init_creds_opt */*opt*/, int /*proxiable*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_get_init_creds_opt_set_renew_life ( krb5_get_init_creds_opt */*opt*/, krb5_deltat /*renew_life*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_get_init_creds_opt_set_salt ( krb5_get_init_creds_opt */*opt*/, krb5_data */*salt*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_get_init_creds_opt_set_tkt_life ( krb5_get_init_creds_opt */*opt*/, krb5_deltat /*tkt_life*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_init_creds_opt_set_win2k ( krb5_context /*context*/, krb5_get_init_creds_opt */*opt*/, krb5_boolean /*req*/); /** * Get new credentials using password. * * @ingroup krb5_credential */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_init_creds_password ( krb5_context /*context*/, krb5_creds */*creds*/, krb5_principal /*client*/, const char */*password*/, krb5_prompter_fct /*prompter*/, void */*data*/, krb5_deltat /*start_time*/, const char */*in_tkt_service*/, krb5_get_init_creds_opt */*options*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_kdc_cred ( krb5_context /*context*/, krb5_ccache /*id*/, krb5_kdc_flags /*flags*/, krb5_addresses */*addresses*/, Ticket */*second_ticket*/, krb5_creds */*in_creds*/, krb5_creds **out_creds ); /** * Get current offset in time to the KDC. * * @param context Kerberos 5 context. * @param sec seconds part of offset. * @param usec micro seconds part of offset. * * @return returns zero * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_kdc_sec_offset ( krb5_context /*context*/, int32_t */*sec*/, int32_t */*usec*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_krb524hst ( krb5_context /*context*/, const krb5_realm */*realm*/, char ***/*hostlist*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_krb_admin_hst ( krb5_context /*context*/, const krb5_realm */*realm*/, char ***/*hostlist*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_krb_changepw_hst ( krb5_context /*context*/, const krb5_realm */*realm*/, char ***/*hostlist*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_krbhst ( krb5_context /*context*/, const krb5_realm */*realm*/, char ***/*hostlist*/); /** * Get max time skew allowed. * * @param context Kerberos 5 context. * * @return timeskew in seconds. * * @ingroup krb5 */ KRB5_LIB_FUNCTION time_t KRB5_LIB_CALL krb5_get_max_time_skew (krb5_context /*context*/); /** * krb5_init_context() will get one random byte to make sure our * random is alive. Assumption is that once the non blocking * source allows us to pull bytes, its all seeded and allows us to * pull more bytes. * * Most Kerberos users calls krb5_init_context(), so this is * useful point where we can do the checking. */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_permitted_enctypes ( krb5_context /*context*/, krb5_enctype **/*etypes*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_pw_salt ( krb5_context /*context*/, krb5_const_principal /*principal*/, krb5_salt */*salt*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_renewed_creds ( krb5_context /*context*/, krb5_creds */*creds*/, krb5_const_principal /*client*/, krb5_ccache /*ccache*/, const char */*in_tkt_service*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_server_rcache ( krb5_context /*context*/, const krb5_data */*piece*/, krb5_rcache */*id*/); /** * Make the kerberos library default to the admin KDC. * * @param context Kerberos 5 context. * * @return boolean flag to telling the context will use admin KDC as the default KDC. * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_get_use_admin_kdc (krb5_context /*context*/); /** * Validate the newly fetch credential, see also krb5_verify_init_creds(). * * @param context a Kerberos 5 context * @param creds the credentials to verify * @param client the client name to match up * @param ccache the credential cache to use * @param service a service name to use, used with * krb5_sname_to_principal() to build a hostname to use to * verify. * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_get_validated_creds ( krb5_context /*context*/, krb5_creds */*creds*/, krb5_principal /*client*/, krb5_ccache /*ccache*/, char */*service*/); /** * Get the default logging facility. * * @param context A Kerberos 5 context * * @ingroup krb5_error */ KRB5_LIB_FUNCTION krb5_log_facility * KRB5_LIB_CALL krb5_get_warn_dest (krb5_context /*context*/); KRB5_LIB_FUNCTION size_t KRB5_LIB_CALL krb5_get_wrapped_length ( krb5_context /*context*/, krb5_crypto /*crypto*/, size_t /*data_len*/); KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_getportbyname ( krb5_context /*context*/, const char */*service*/, const char */*proto*/, int /*default_port*/); /** * krb5_h_addr2addr works like krb5_h_addr2sockaddr with the exception * that it operates on a krb5_address instead of a struct sockaddr. * * @param context a Keberos context * @param af address family * @param haddr host address from struct hostent. * @param addr returned krb5_address. * * @return Return an error code or 0. * * @ingroup krb5_address */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_h_addr2addr ( krb5_context /*context*/, int /*af*/, const char */*haddr*/, krb5_address */*addr*/); /** * krb5_h_addr2sockaddr initializes a "struct sockaddr sa" from af and * the "struct hostent" (see gethostbyname(3) ) h_addr_list * component. The argument sa_size should initially contain the size * of the sa, and after the call, it will contain the actual length of * the address. * * @param context a Keberos context * @param af addresses * @param addr address * @param sa returned struct sockaddr * @param sa_size size of sa * @param port port to set in sa. * * @return Return an error code or 0. * * @ingroup krb5_address */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_h_addr2sockaddr ( krb5_context /*context*/, int /*af*/, const char */*addr*/, struct sockaddr */*sa*/, krb5_socklen_t */*sa_size*/, int /*port*/); /** * Convert the gethostname() error code (h_error) to a Kerberos et * error code. * * @param eai_errno contains the error code from gethostname(). * * @return Kerberos error code representing the gethostname errors. * * @ingroup krb5_error */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_h_errno_to_heim_errno (int /*eai_errno*/); KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_have_error_string (krb5_context /*context*/) KRB5_DEPRECATED_FUNCTION("Use krb5_get_error_message instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_hmac ( krb5_context /*context*/, krb5_cksumtype /*cktype*/, const void */*data*/, size_t /*len*/, unsigned /*usage*/, krb5_keyblock */*key*/, Checksum */*result*/); /** * Initializes the context structure and reads the configuration file * /etc/krb5.conf. The structure should be freed by calling * krb5_free_context() when it is no longer being used. * * @param context pointer to returned context * * @return Returns 0 to indicate success. Otherwise an errno code is * returned. Failure means either that something bad happened during * initialization (typically ENOMEM) or that Kerberos should not be * used ENXIO. If the function returns HEIM_ERR_RANDOM_OFFLINE, the * random source is not available and later Kerberos calls might fail. * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_init_context (krb5_context */*context*/); /** * Free the krb5_init_creds_context allocated by krb5_init_creds_init(). * * @param context A Kerberos 5 context. * @param ctx The krb5_init_creds_context to free. * * @ingroup krb5_credential */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_init_creds_free ( krb5_context /*context*/, krb5_init_creds_context /*ctx*/); /** * Get new credentials as setup by the krb5_init_creds_context. * * @param context A Kerberos 5 context. * @param ctx The krb5_init_creds_context to process. * * @ingroup krb5_credential */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_init_creds_get ( krb5_context /*context*/, krb5_init_creds_context /*ctx*/); /** * Extract the newly acquired credentials from krb5_init_creds_context * context. * * @param context A Kerberos 5 context. * @param ctx * @param cred credentials, free with krb5_free_cred_contents(). * * @return 0 for sucess or An Kerberos error code, see krb5_get_error_message(). */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_init_creds_get_creds ( krb5_context /*context*/, krb5_init_creds_context /*ctx*/, krb5_creds */*cred*/); /** * Get the last error from the transaction. * * @return Returns 0 or an error code * * @ingroup krb5_credential */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_init_creds_get_error ( krb5_context /*context*/, krb5_init_creds_context /*ctx*/, KRB_ERROR */*error*/); /** * Start a new context to get a new initial credential. * * @param context A Kerberos 5 context. * @param client The Kerberos principal to get the credential for, if * NULL is given, the default principal is used as determined by * krb5_get_default_principal(). * @param prompter * @param prompter_data * @param start_time the time the ticket should start to be valid or 0 for now. * @param options a options structure, can be NULL for default options. * @param rctx A new allocated free with krb5_init_creds_free(). * * @return 0 for success or an Kerberos 5 error code, see krb5_get_error_message(). * * @ingroup krb5_credential */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_init_creds_init ( krb5_context /*context*/, krb5_principal /*client*/, krb5_prompter_fct /*prompter*/, void */*prompter_data*/, krb5_deltat /*start_time*/, krb5_get_init_creds_opt */*options*/, krb5_init_creds_context */*rctx*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_init_creds_set_fast_ap_armor_service ( krb5_context /*context*/, krb5_init_creds_context /*ctx*/, krb5_const_principal /*armor_service*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_init_creds_set_fast_ccache ( krb5_context /*context*/, krb5_init_creds_context /*ctx*/, krb5_ccache /*fast_ccache*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_init_creds_set_keyblock ( krb5_context /*context*/, krb5_init_creds_context /*ctx*/, krb5_keyblock */*keyblock*/); /** * Set the keytab to use for authentication. * * @param context a Kerberos 5 context. * @param ctx ctx krb5_init_creds_context context. * @param keytab the keytab to read the key from. * * @return 0 for success, or an Kerberos 5 error code, see krb5_get_error_message(). * @ingroup krb5_credential */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_init_creds_set_keytab ( krb5_context /*context*/, krb5_init_creds_context /*ctx*/, krb5_keytab /*keytab*/); /** * Sets the password that will use for the request. * * @param context a Kerberos 5 context. * @param ctx ctx krb5_init_creds_context context. * @param password the password to use. * * @return 0 for success, or an Kerberos 5 error code, see krb5_get_error_message(). * @ingroup krb5_credential */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_init_creds_set_password ( krb5_context /*context*/, krb5_init_creds_context /*ctx*/, const char */*password*/); /** * Sets the service that the is requested. This call is only neede for * special initial tickets, by default the a krbtgt is fetched in the default realm. * * @param context a Kerberos 5 context. * @param ctx a krb5_init_creds_context context. * @param service the service given as a string, for example * "kadmind/admin". If NULL, the default krbtgt in the clients * realm is set. * * @return 0 for success, or an Kerberos 5 error code, see krb5_get_error_message(). * @ingroup krb5_credential */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_init_creds_set_service ( krb5_context /*context*/, krb5_init_creds_context /*ctx*/, const char */*service*/); /** * The core loop if krb5_get_init_creds() function family. Create the * packets and have the caller send them off to the KDC. * * If the caller want all work been done for them, use * krb5_init_creds_get() instead. * * @param context a Kerberos 5 context. * @param ctx ctx krb5_init_creds_context context. * @param in input data from KDC, first round it should be reset by krb5_data_zer(). * @param out reply to KDC. * @param hostinfo KDC address info, first round it can be NULL. * @param flags status of the round, if * KRB5_INIT_CREDS_STEP_FLAG_CONTINUE is set, continue one more round. * * @return 0 for success, or an Kerberos 5 error code, see * krb5_get_error_message(). * * @ingroup krb5_credential */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_init_creds_step ( krb5_context /*context*/, krb5_init_creds_context /*ctx*/, krb5_data */*in*/, krb5_data */*out*/, krb5_krbhst_info */*hostinfo*/, unsigned int */*flags*/); /** * * @ingroup krb5_credential */ krb5_error_code krb5_init_creds_store ( krb5_context /*context*/, krb5_init_creds_context /*ctx*/, krb5_ccache /*id*/); /** * Init the built-in ets in the Kerberos library. * * @param context kerberos context to add the ets too * * @ingroup krb5 */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_init_ets (krb5_context /*context*/); /** @struct krb5plugin_kuserok_ftable_desc * * @brief Description of the krb5_kuserok(3) plugin facility. * * The krb5_kuserok(3) function is pluggable. The plugin is named * KRB5_PLUGIN_KUSEROK ("krb5_plugin_kuserok"), with a single minor * version, KRB5_PLUGIN_KUSEROK_VERSION_0 (0). * * The plugin for krb5_kuserok(3) consists of a data symbol referencing * a structure of type krb5plugin_kuserok_ftable, with four fields: * * @param init Plugin initialization function (see krb5-plugin(7)) * * @param minor_version The plugin minor version number (0) * * @param fini Plugin finalization function * * @param kuserok Plugin kuserok function * * The kuserok field is the plugin entry point that performs the * traditional kuserok operation however the plugin desires. It is * invoked in no particular order relative to other kuserok plugins, but * it has a 'rule' argument that indicates which plugin is intended to * act on the rule. The plugin kuserok function must return * KRB5_PLUGIN_NO_HANDLE if the rule is not applicable to it. * * The plugin kuserok function has the following arguments, in this * order: * * -# plug_ctx, the context value output by the plugin's init function * -# context, a krb5_context * -# rule, the kuserok rule being evaluated (from krb5.conf(5)) * -# flags * -# k5login_dir, configured location of k5login per-user files if any * -# luser, name of the local user account to which principal is attempting to access. * -# principal, the krb5_principal trying to access the luser account * -# result, a krb5_boolean pointer where the plugin will output its result * * @ingroup krb5_support */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_initlog ( krb5_context /*context*/, const char */*program*/, krb5_log_facility **/*fac*/); /** * Return TRUE (non zero) if the principal is a configuration * principal (generated part of krb5_cc_set_config()). Returns FALSE * (zero) if not a configuration principal. * * @param context a Keberos context * @param principal principal to check if it a configuration principal * * @ingroup krb5_ccache */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_is_config_principal ( krb5_context /*context*/, krb5_const_principal /*principal*/); /** * Returns is the encryption is strong or weak * * @param context Kerberos 5 context * @param enctype encryption type to probe * * @return Returns true if encryption type is weak or is not supported. * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_is_enctype_weak ( krb5_context /*context*/, krb5_enctype /*enctype*/); /** * Runtime check if the Kerberos library was complied with thread support. * * @return TRUE if the library was compiled with thread support, FALSE if not. * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_is_thread_safe (void); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kcm_call ( krb5_context /*context*/, krb5_storage */*request*/, krb5_storage **/*response_p*/, krb5_data */*response_data_p*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kcm_storage_request ( krb5_context /*context*/, uint16_t /*opcode*/, krb5_storage **/*storage_p*/); /** * Returns the list of Kerberos encryption types sorted in order of * most preferred to least preferred encryption type. Note that some * encryption types might be disabled, so you need to check with * krb5_enctype_valid() before using the encryption type. * * @return list of enctypes, terminated with ETYPE_NULL. Its a static * array completed into the Kerberos library so the content doesn't * need to be freed. * * @ingroup krb5 */ KRB5_LIB_FUNCTION const krb5_enctype * KRB5_LIB_CALL krb5_kerberos_enctypes (krb5_context /*context*/); /** * Get encryption type of a keyblock. * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_enctype KRB5_LIB_CALL krb5_keyblock_get_enctype (const krb5_keyblock */*block*/); /** * Fill in `key' with key data of type `enctype' from `data' of length * `size'. Key should be freed using krb5_free_keyblock_contents(). * * @return 0 on success or a Kerberos 5 error code * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_keyblock_init ( krb5_context /*context*/, krb5_enctype /*type*/, const void */*data*/, size_t /*size*/, krb5_keyblock */*key*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_keyblock_key_proc ( krb5_context /*context*/, krb5_keytype /*type*/, krb5_data */*salt*/, krb5_const_pointer /*keyseed*/, krb5_keyblock **/*key*/); /** * Zero out a keyblock * * @param keyblock keyblock to zero out * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_keyblock_zero (krb5_keyblock */*keyblock*/); /** * Deprecated: use krb5_get_init_creds() and friends. * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_CALLCONV krb5_keytab_key_proc ( krb5_context /*context*/, krb5_enctype /*enctype*/, krb5_salt /*salt*/, krb5_const_pointer /*keyseed*/, krb5_keyblock **/*key*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Deprecated: keytypes doesn't exists, they are really enctypes. * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_keytype_to_enctypes ( krb5_context /*context*/, krb5_keytype /*keytype*/, unsigned */*len*/, krb5_enctype **/*val*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Deprecated: keytypes doesn't exists, they are really enctypes. * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_keytype_to_enctypes_default ( krb5_context /*context*/, krb5_keytype /*keytype*/, unsigned */*len*/, krb5_enctype **/*val*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Deprecated: keytypes doesn't exists, they are really enctypes in * most cases, use krb5_enctype_to_string(). * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_keytype_to_string ( krb5_context /*context*/, krb5_keytype /*keytype*/, char **/*string*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_krbhst_format_string ( krb5_context /*context*/, const krb5_krbhst_info */*host*/, char */*hostname*/, size_t /*hostlen*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_krbhst_free ( krb5_context /*context*/, krb5_krbhst_handle /*handle*/); /** * Return an `struct addrinfo *' for a KDC host. * * Returns an the struct addrinfo in in that corresponds to the * information in `host'. free:ing is handled by krb5_krbhst_free, so * the returned ai must not be released. * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_krbhst_get_addrinfo ( krb5_context /*context*/, krb5_krbhst_info */*host*/, struct addrinfo **/*ai*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_krbhst_init ( krb5_context /*context*/, const char */*realm*/, unsigned int /*type*/, krb5_krbhst_handle */*handle*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_krbhst_init_flags ( krb5_context /*context*/, const char */*realm*/, unsigned int /*type*/, int /*flags*/, krb5_krbhst_handle */*handle*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_krbhst_next ( krb5_context /*context*/, krb5_krbhst_handle /*handle*/, krb5_krbhst_info **/*host*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_krbhst_next_as_string ( krb5_context /*context*/, krb5_krbhst_handle /*handle*/, char */*hostname*/, size_t /*hostlen*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_krbhst_reset ( krb5_context /*context*/, krb5_krbhst_handle /*handle*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_krbhst_set_hostname ( krb5_context /*context*/, krb5_krbhst_handle /*handle*/, const char */*hostname*/); /** * Add the entry in `entry' to the keytab `id'. * * @param context a Keberos context. * @param id a keytab. * @param entry the entry to add * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_add_entry ( krb5_context /*context*/, krb5_keytab /*id*/, krb5_keytab_entry */*entry*/); /** * Finish using the keytab in `id'. All resources will be released, * even on errors. * * @param context a Keberos context. * @param id keytab to close. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_close ( krb5_context /*context*/, krb5_keytab /*id*/); /** * Compare `entry' against `principal, vno, enctype'. * Any of `principal, vno, enctype' might be 0 which acts as a wildcard. * Return TRUE if they compare the same, FALSE otherwise. * * @param context a Keberos context. * @param entry an entry to match with. * @param principal principal to match, NULL matches all principals. * @param vno key version to match, 0 matches all key version numbers. * @param enctype encryption type to match, 0 matches all encryption types. * * @return Return TRUE or match, FALSE if not matched. * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_kt_compare ( krb5_context /*context*/, krb5_keytab_entry */*entry*/, krb5_const_principal /*principal*/, krb5_kvno /*vno*/, krb5_enctype /*enctype*/); /** * Copy the contents of `in' into `out'. * * @param context a Keberos context. * @param in the keytab entry to copy. * @param out the copy of the keytab entry, free with krb5_kt_free_entry(). * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_copy_entry_contents ( krb5_context /*context*/, const krb5_keytab_entry */*in*/, krb5_keytab_entry */*out*/); /** * Set `id' to the default keytab. * * @param context a Keberos context. * @param id the new default keytab. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_default ( krb5_context /*context*/, krb5_keytab */*id*/); /** * Copy the name of the default modify keytab into `name'. * * @param context a Keberos context. * @param name buffer where the name will be written * @param namesize length of name * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_default_modify_name ( krb5_context /*context*/, char */*name*/, size_t /*namesize*/); /** * copy the name of the default keytab into `name'. * * @param context a Keberos context. * @param name buffer where the name will be written * @param namesize length of name * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_default_name ( krb5_context /*context*/, char */*name*/, size_t /*namesize*/); /** * Destroy (remove) the keytab in `id'. All resources will be released, * even on errors, does the equvalment of krb5_kt_close() on the resources. * * @param context a Keberos context. * @param id keytab to destroy. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_destroy ( krb5_context /*context*/, krb5_keytab /*id*/); /** * Release all resources associated with `cursor'. * * @param context a Keberos context. * @param id a keytab. * @param cursor the cursor to free. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_end_seq_get ( krb5_context /*context*/, krb5_keytab /*id*/, krb5_kt_cursor */*cursor*/); /** * Free the contents of `entry'. * * @param context a Keberos context. * @param entry the entry to free * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_free_entry ( krb5_context /*context*/, krb5_keytab_entry */*entry*/); /** * Retrieve the keytab entry for `principal, kvno, enctype' into `entry' * from the keytab `id'. Matching is done like krb5_kt_compare(). * * @param context a Keberos context. * @param id a keytab. * @param principal principal to match, NULL matches all principals. * @param kvno key version to match, 0 matches all key version numbers. * @param enctype encryption type to match, 0 matches all encryption types. * @param entry the returned entry, free with krb5_kt_free_entry(). * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_get_entry ( krb5_context /*context*/, krb5_keytab /*id*/, krb5_const_principal /*principal*/, krb5_kvno /*kvno*/, krb5_enctype /*enctype*/, krb5_keytab_entry */*entry*/); /** * Retrieve the full name of the keytab `keytab' and store the name in * `str'. * * @param context a Keberos context. * @param keytab keytab to get name for. * @param str the name of the keytab name, usee krb5_xfree() to free * the string. On error, *str is set to NULL. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_get_full_name ( krb5_context /*context*/, krb5_keytab /*keytab*/, char **/*str*/); /** * Retrieve the name of the keytab `keytab' into `name', `namesize' * * @param context a Keberos context. * @param keytab the keytab to get the name for. * @param name name buffer. * @param namesize size of name buffer. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_get_name ( krb5_context /*context*/, krb5_keytab /*keytab*/, char */*name*/, size_t /*namesize*/); /** * Return the type of the `keytab' in the string `prefix of length * `prefixsize'. * * @param context a Keberos context. * @param keytab the keytab to get the prefix for * @param prefix prefix buffer * @param prefixsize length of prefix buffer * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_get_type ( krb5_context /*context*/, krb5_keytab /*keytab*/, char */*prefix*/, size_t /*prefixsize*/); /** * Return true if the keytab exists and have entries * * @param context a Keberos context. * @param id a keytab. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_have_content ( krb5_context /*context*/, krb5_keytab /*id*/); /** * Get the next entry from keytab, advance the cursor. On last entry * the function will return KRB5_KT_END. * * @param context a Keberos context. * @param id a keytab. * @param entry the returned entry, free with krb5_kt_free_entry(). * @param cursor the cursor of the iteration. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_next_entry ( krb5_context /*context*/, krb5_keytab /*id*/, krb5_keytab_entry */*entry*/, krb5_kt_cursor */*cursor*/); /** * Read the key identified by `(principal, vno, enctype)' from the * keytab in `keyprocarg' (the default if == NULL) into `*key'. * * @param context a Keberos context. * @param keyprocarg * @param principal * @param vno * @param enctype * @param key * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_read_service_key ( krb5_context /*context*/, krb5_pointer /*keyprocarg*/, krb5_principal /*principal*/, krb5_kvno /*vno*/, krb5_enctype /*enctype*/, krb5_keyblock **/*key*/); /** * Register a new keytab backend. * * @param context a Keberos context. * @param ops a backend to register. * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_register ( krb5_context /*context*/, const krb5_kt_ops */*ops*/); /** * Remove an entry from the keytab, matching is done using * krb5_kt_compare(). * @param context a Keberos context. * @param id a keytab. * @param entry the entry to remove * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_remove_entry ( krb5_context /*context*/, krb5_keytab /*id*/, krb5_keytab_entry */*entry*/); /** * Resolve the keytab name (of the form `type:residual') in `name' * into a keytab in `id'. * * @param context a Keberos context. * @param name name to resolve * @param id resulting keytab, free with krb5_kt_close(). * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_resolve ( krb5_context /*context*/, const char */*name*/, krb5_keytab */*id*/); /** * Set `cursor' to point at the beginning of `id'. * * @param context a Keberos context. * @param id a keytab. * @param cursor a newly allocated cursor, free with krb5_kt_end_seq_get(). * * @return Return an error code or 0, see krb5_get_error_message(). * * @ingroup krb5_keytab */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_kt_start_seq_get ( krb5_context /*context*/, krb5_keytab /*id*/, krb5_kt_cursor */*cursor*/); /** * This function takes the name of a local user and checks if * principal is allowed to log in as that user. * * The user may have a ~/.k5login file listing principals that are * allowed to login as that user. If that file does not exist, all * principals with a only one component that is identical to the * username, and a realm considered local, are allowed access. * * The .k5login file must contain one principal per line, be owned by * user and not be writable by group or other (but must be readable by * anyone). * * Note that if the file exists, no implicit access rights are given * to user@@LOCALREALM. * * Optionally, a set of files may be put in ~/.k5login.d (a * directory), in which case they will all be checked in the same * manner as .k5login. The files may be called anything, but files * starting with a hash (#) , or ending with a tilde (~) are * ignored. Subdirectories are not traversed. Note that this directory * may not be checked by other Kerberos implementations. * * If no configuration file exists, match user against local domains, * ie luser@@LOCAL-REALMS-IN-CONFIGURATION-FILES. * * @param context Kerberos 5 context. * @param principal principal to check if allowed to login * @param luser local user id * * @return returns TRUE if access should be granted, FALSE otherwise. * * @ingroup krb5_support */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_kuserok ( krb5_context /*context*/, krb5_principal /*principal*/, const char */*luser*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_log ( krb5_context /*context*/, krb5_log_facility */*fac*/, int /*level*/, const char */*fmt*/, ...) __attribute__ ((__format__ (__printf__, 4, 5))); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_log_msg ( krb5_context /*context*/, krb5_log_facility */*fac*/, int /*level*/, char **/*reply*/, const char */*fmt*/, ...) __attribute__ ((__format__ (__printf__, 5, 6))); /** * Create an address of type KRB5_ADDRESS_ADDRPORT from (addr, port) * * @param context a Keberos context * @param res built address from addr/port * @param addr address to use * @param port port to use * * @return Return an error code or 0. * * @ingroup krb5_address */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_make_addrport ( krb5_context /*context*/, krb5_address **/*res*/, const krb5_address */*addr*/, int16_t /*port*/); /** * Build a principal using vararg style building * * @param context A Kerberos context. * @param principal returned principal * @param realm realm name * @param ... a list of components ended with NULL. * * @return An krb5 error code, see krb5_get_error_message(). * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_make_principal ( krb5_context /*context*/, krb5_principal */*principal*/, krb5_const_realm /*realm*/, ...); /** * krb5_max_sockaddr_size returns the max size of the .Li struct * sockaddr that the Kerberos library will return. * * @return Return an size_t of the maximum struct sockaddr. * * @ingroup krb5_address */ KRB5_LIB_FUNCTION size_t KRB5_LIB_CALL krb5_max_sockaddr_size (void); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_mk_error ( krb5_context /*context*/, krb5_error_code /*error_code*/, const char */*e_text*/, const krb5_data */*e_data*/, const krb5_principal /*client*/, const krb5_principal /*server*/, time_t */*client_time*/, int */*client_usec*/, krb5_data */*reply*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_mk_error_ext ( krb5_context /*context*/, krb5_error_code /*error_code*/, const char */*e_text*/, const krb5_data */*e_data*/, const krb5_principal /*server*/, const PrincipalName */*client_name*/, const Realm */*client_realm*/, time_t */*client_time*/, int */*client_usec*/, krb5_data */*reply*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_mk_priv ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, const krb5_data */*userdata*/, krb5_data */*outbuf*/, krb5_replay_data */*outdata*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_mk_rep ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_data */*outbuf*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_mk_req ( krb5_context /*context*/, krb5_auth_context */*auth_context*/, const krb5_flags /*ap_req_options*/, const char */*service*/, const char */*hostname*/, krb5_data */*in_data*/, krb5_ccache /*ccache*/, krb5_data */*outbuf*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_mk_req_exact ( krb5_context /*context*/, krb5_auth_context */*auth_context*/, const krb5_flags /*ap_req_options*/, const krb5_principal /*server*/, krb5_data */*in_data*/, krb5_ccache /*ccache*/, krb5_data */*outbuf*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_mk_req_extended ( krb5_context /*context*/, krb5_auth_context */*auth_context*/, const krb5_flags /*ap_req_options*/, krb5_data */*in_data*/, krb5_creds */*in_creds*/, krb5_data */*outbuf*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_mk_safe ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, const krb5_data */*userdata*/, krb5_data */*outbuf*/, krb5_replay_data */*outdata*/); /** * Iteratively apply name canon rules, outputing a principal and rule * options each time. Iteration completes when the @iter is NULL on * return or when an error is returned. Callers must free the iterator * if they abandon it mid-way. * * @param context Kerberos context * @param iter name canon rule iterator (input/output) * @param try_princ output principal name * @param rule_opts output rule options */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_name_canon_iterate ( krb5_context /*context*/, krb5_name_canon_iterator */*iter*/, krb5_const_principal */*try_princ*/, krb5_name_canon_rule_options */*rule_opts*/); /** * Initialize name canonicalization iterator. * * @param context Kerberos context * @param in_princ principal name to be canonicalized OR * @param iter output iterator object */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_name_canon_iterator_start ( krb5_context /*context*/, krb5_const_principal /*in_princ*/, krb5_name_canon_iterator */*iter*/); /** * Read \a len bytes from socket \a p_fd into buffer \a buf. * Block until \a len bytes are read or until an error. * * @return If successful, the number of bytes read: \a len. * On end-of-file, 0. * On error, less than 0 (if single-threaded, the error can be found * in the errno global variable). */ KRB5_LIB_FUNCTION krb5_ssize_t KRB5_LIB_CALL krb5_net_read ( krb5_context /*context*/, void */*p_fd*/, void */*buf*/, size_t /*len*/); KRB5_LIB_FUNCTION krb5_ssize_t KRB5_LIB_CALL krb5_net_write ( krb5_context /*context*/, void */*p_fd*/, const void */*buf*/, size_t /*len*/); KRB5_LIB_FUNCTION krb5_ssize_t KRB5_LIB_CALL krb5_net_write_block ( krb5_context /*context*/, void */*p_fd*/, const void */*buf*/, size_t /*len*/, time_t /*timeout*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ntlm_alloc ( krb5_context /*context*/, krb5_ntlm */*ntlm*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ntlm_free ( krb5_context /*context*/, krb5_ntlm /*ntlm*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ntlm_init_get_challenge ( krb5_context /*context*/, krb5_ntlm /*ntlm*/, krb5_data */*challenge*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ntlm_init_get_flags ( krb5_context /*context*/, krb5_ntlm /*ntlm*/, uint32_t */*flags*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ntlm_init_get_opaque ( krb5_context /*context*/, krb5_ntlm /*ntlm*/, krb5_data */*opaque*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ntlm_init_get_targetinfo ( krb5_context /*context*/, krb5_ntlm /*ntlm*/, krb5_data */*data*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ntlm_init_get_targetname ( krb5_context /*context*/, krb5_ntlm /*ntlm*/, char **/*name*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ntlm_init_request ( krb5_context /*context*/, krb5_ntlm /*ntlm*/, krb5_realm /*realm*/, krb5_ccache /*ccache*/, uint32_t /*flags*/, const char */*hostname*/, const char */*domainname*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ntlm_rep_get_sessionkey ( krb5_context /*context*/, krb5_ntlm /*ntlm*/, krb5_data */*data*/); KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_ntlm_rep_get_status ( krb5_context /*context*/, krb5_ntlm /*ntlm*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ntlm_req_set_flags ( krb5_context /*context*/, krb5_ntlm /*ntlm*/, uint32_t /*flags*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ntlm_req_set_lm ( krb5_context /*context*/, krb5_ntlm /*ntlm*/, void */*hash*/, size_t /*len*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ntlm_req_set_ntlm ( krb5_context /*context*/, krb5_ntlm /*ntlm*/, void */*hash*/, size_t /*len*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ntlm_req_set_opaque ( krb5_context /*context*/, krb5_ntlm /*ntlm*/, krb5_data */*opaque*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ntlm_req_set_session ( krb5_context /*context*/, krb5_ntlm /*ntlm*/, void */*sessionkey*/, size_t /*length*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ntlm_req_set_targetname ( krb5_context /*context*/, krb5_ntlm /*ntlm*/, const char */*targetname*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ntlm_req_set_username ( krb5_context /*context*/, krb5_ntlm /*ntlm*/, const char */*username*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ntlm_request ( krb5_context /*context*/, krb5_ntlm /*ntlm*/, krb5_realm /*realm*/, krb5_ccache /*ccache*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_openlog ( krb5_context /*context*/, const char */*program*/, krb5_log_facility **/*fac*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_pac_add_buffer ( krb5_context /*context*/, krb5_pac /*p*/, uint32_t /*type*/, const krb5_data */*data*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_pac_free ( krb5_context /*context*/, krb5_pac /*pac*/); /** * Get the PAC buffer of specific type from the pac. * * @param context Kerberos 5 context. * @param p the pac structure returned by krb5_pac_parse(). * @param type type of buffer to get * @param data return data, free with krb5_data_free(). * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5_pac */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_pac_get_buffer ( krb5_context /*context*/, krb5_pac /*p*/, uint32_t /*type*/, krb5_data */*data*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_pac_get_types ( krb5_context /*context*/, krb5_pac /*p*/, size_t */*len*/, uint32_t **/*types*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_pac_init ( krb5_context /*context*/, krb5_pac */*pac*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_pac_parse ( krb5_context /*context*/, const void */*ptr*/, size_t /*len*/, krb5_pac */*pac*/); /** * Verify the PAC. * * @param context Kerberos 5 context. * @param pac the pac structure returned by krb5_pac_parse(). * @param authtime The time of the ticket the PAC belongs to. * @param principal the principal to verify. * @param server The service key, most always be given. * @param privsvr The KDC key, may be given. * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5_pac */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_pac_verify ( krb5_context /*context*/, const krb5_pac /*pac*/, time_t /*authtime*/, krb5_const_principal /*principal*/, const krb5_keyblock */*server*/, const krb5_keyblock */*privsvr*/); KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_padata_add ( krb5_context /*context*/, METHOD_DATA */*md*/, int /*type*/, void */*buf*/, size_t /*len*/); /** * krb5_parse_address returns the resolved hostname in string to the * krb5_addresses addresses . * * @param context a Keberos context * @param string * @param addresses * * @return Return an error code or 0. * * @ingroup krb5_address */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_parse_address ( krb5_context /*context*/, const char */*string*/, krb5_addresses */*addresses*/); /** * Parse a name into a krb5_principal structure * * @param context Kerberos 5 context * @param name name to parse into a Kerberos principal * @param principal returned principal, free with krb5_free_principal(). * * @return An krb5 error code, see krb5_get_error_message(). * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_parse_name ( krb5_context /*context*/, const char */*name*/, krb5_principal */*principal*/); /** * Parse a name into a krb5_principal structure, flags controls the behavior. * * @param context Kerberos 5 context * @param name name to parse into a Kerberos principal * @param flags flags to control the behavior * @param principal returned principal, free with krb5_free_principal(). * * @return An krb5 error code, see krb5_get_error_message(). * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_parse_name_flags ( krb5_context /*context*/, const char */*name*/, int /*flags*/, krb5_principal */*principal*/); /** * Parse nametype string and return a nametype integer * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_parse_nametype ( krb5_context /*context*/, const char */*str*/, int32_t */*nametype*/); KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL krb5_passwd_result_to_string ( krb5_context /*context*/, int /*result*/); /** * Deprecated: use krb5_get_init_creds() and friends. * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_CALLCONV krb5_password_key_proc ( krb5_context /*context*/, krb5_enctype /*type*/, krb5_salt /*salt*/, krb5_const_pointer /*keyseed*/, krb5_keyblock **/*key*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_pk_enterprise_cert ( krb5_context /*context*/, const char */*user_id*/, krb5_const_realm /*realm*/, krb5_principal */*principal*/, struct hx509_certs_data **/*res*/); /** * Register a plugin symbol name of specific type. * @param context a Keberos context * @param type type of plugin symbol * @param name name of plugin symbol * @param symbol a pointer to the named symbol * @return In case of error a non zero error com_err error is returned * and the Kerberos error string is set. * * @ingroup krb5_support */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_plugin_register ( krb5_context /*context*/, enum krb5_plugin_type /*type*/, const char */*name*/, void */*symbol*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_prepend_config_files ( const char */*filelist*/, char **/*pq*/, char ***/*ret_pp*/); /** * Prepend the filename to the global configuration list. * * @param filelist a filename to add to the default list of filename * @param pfilenames return array of filenames, should be freed with krb5_free_config_files(). * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_prepend_config_files_default ( const char */*filelist*/, char ***/*pfilenames*/); /** * Prepend the context full error string for a specific error code. * The error that is stored should be internationalized. * * The if context is NULL, no error string is stored. * * @param context Kerberos 5 context * @param ret The error code * @param fmt Error string for the error code * @param ... printf(3) style parameters. * * @ingroup krb5_error */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_prepend_error_message ( krb5_context /*context*/, krb5_error_code /*ret*/, const char */*fmt*/, ...) __attribute__ ((__format__ (__printf__, 3, 4))); /** * Deprecated: use krb5_principal_get_realm() * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_realm * KRB5_LIB_CALL krb5_princ_realm ( krb5_context /*context*/, krb5_principal /*principal*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Deprecated: use krb5_principal_set_realm() * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_princ_set_realm ( krb5_context /*context*/, krb5_principal /*principal*/, krb5_realm */*realm*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Compares the two principals, including realm of the principals and returns * TRUE if they are the same and FALSE if not. * * @param context Kerberos 5 context * @param princ1 first principal to compare * @param princ2 second principal to compare * * @ingroup krb5_principal * @see krb5_principal_compare_any_realm() * @see krb5_realm_compare() */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_principal_compare ( krb5_context /*context*/, krb5_const_principal /*princ1*/, krb5_const_principal /*princ2*/); /** * Return TRUE iff princ1 == princ2 (without considering the realm) * * @param context Kerberos 5 context * @param princ1 first principal to compare * @param princ2 second principal to compare * * @return non zero if equal, 0 if not * * @ingroup krb5_principal * @see krb5_principal_compare() * @see krb5_realm_compare() */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_principal_compare_any_realm ( krb5_context /*context*/, krb5_const_principal /*princ1*/, krb5_const_principal /*princ2*/); KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL krb5_principal_get_comp_string ( krb5_context /*context*/, krb5_const_principal /*principal*/, unsigned int /*component*/); /** * Get number of component is principal. * * @param context Kerberos 5 context * @param principal principal to query * * @return number of components in string * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION unsigned int KRB5_LIB_CALL krb5_principal_get_num_comp ( krb5_context /*context*/, krb5_const_principal /*principal*/); /** * Get the realm of the principal * * @param context A Kerberos context. * @param principal principal to get the realm for * * @return realm of the principal, don't free or use after krb5_principal is freed * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL krb5_principal_get_realm ( krb5_context /*context*/, krb5_const_principal /*principal*/); /** * Get the type of the principal * * @param context A Kerberos context. * @param principal principal to get the type for * * @return the type of principal * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_principal_get_type ( krb5_context /*context*/, krb5_const_principal /*principal*/); /** * Returns true iff name is WELLKNOWN/ANONYMOUS * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_principal_is_anonymous ( krb5_context /*context*/, krb5_const_principal /*p*/, unsigned int /*flags*/); /** * Returns true iff name is an WELLKNOWN:ORG.H5L.HOSTBASED-SERVICE * * @ingroup krb5_principal */ krb5_boolean KRB5_LIB_FUNCTION krb5_principal_is_gss_hostbased_service ( krb5_context /*context*/, krb5_const_principal /*principal*/); /** * Check if the cname part of the principal is a krbtgt principal * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_principal_is_krbtgt ( krb5_context /*context*/, krb5_const_principal /*p*/); /** * Returns true if name is Kerberos an LKDC realm * * @ingroup krb5_principal */ krb5_boolean KRB5_LIB_FUNCTION krb5_principal_is_lkdc ( krb5_context /*context*/, krb5_const_principal /*principal*/); /** * Returns true if name is Kerberos NULL name * * @ingroup krb5_principal */ krb5_boolean KRB5_LIB_FUNCTION krb5_principal_is_null ( krb5_context /*context*/, krb5_const_principal /*principal*/); /** * Returns true if name is Kerberos an LKDC realm * * @ingroup krb5_principal */ krb5_boolean KRB5_LIB_FUNCTION krb5_principal_is_pku2u ( krb5_context /*context*/, krb5_const_principal /*principal*/); /** * Check if the cname part of the principal is a initial or renewed krbtgt principal * * @ingroup krb5_principal */ krb5_boolean KRB5_LIB_FUNCTION krb5_principal_is_root_krbtgt ( krb5_context /*context*/, krb5_const_principal /*p*/); /** * return TRUE iff princ matches pattern * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_principal_match ( krb5_context /*context*/, krb5_const_principal /*princ*/, krb5_const_principal /*pattern*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_principal_set_comp_string ( krb5_context /*context*/, krb5_principal /*principal*/, unsigned int /*k*/, const char */*component*/); /** * Set a new realm for a principal, and as a side-effect free the * previous realm. * * @param context A Kerberos context. * @param principal principal set the realm for * @param realm the new realm to set * * @return An krb5 error code, see krb5_get_error_message(). * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_principal_set_realm ( krb5_context /*context*/, krb5_principal /*principal*/, krb5_const_realm /*realm*/); /** * Set the type of the principal * * @param context A Kerberos context. * @param principal principal to set the type for * @param type the new type * * @return An krb5 error code, see krb5_get_error_message(). * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_principal_set_type ( krb5_context /*context*/, krb5_principal /*principal*/, int /*type*/); /** * krb5_print_address prints the address in addr to the string string * that have the length len. If ret_len is not NULL, it will be filled * with the length of the string if size were unlimited (not including * the final NUL) . * * @param addr address to be printed * @param str pointer string to print the address into * @param len length that will fit into area pointed to by "str". * @param ret_len return length the str. * * @return Return an error code or 0. * * @ingroup krb5_address */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_print_address ( const krb5_address */*addr*/, char */*str*/, size_t /*len*/, size_t */*ret_len*/); krb5_error_code krb5_process_last_request ( krb5_context /*context*/, krb5_get_init_creds_opt */*options*/, krb5_init_creds_context /*ctx*/); KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_program_setup ( krb5_context */*context*/, int /*argc*/, char **/*argv*/, struct getargs */*args*/, int /*num_args*/, void (KRB5_LIB_CALL *usage)(int, struct getargs*, int)); KRB5_LIB_FUNCTION int KRB5_CALLCONV krb5_prompter_posix ( krb5_context /*context*/, void */*data*/, const char */*name*/, const char */*banner*/, int /*num_prompts*/, krb5_prompt prompts[]); /** * Converts the random bytestring to a protocol key according to * Kerberos crypto frame work. It may be assumed that all the bits of * the input string are equally random, even though the entropy * present in the random source may be limited. * * @param context Kerberos 5 context * @param type the enctype resulting key will be of * @param data input random data to convert to a key * @param size size of input random data, at least krb5_enctype_keysize() long * @param key key, output key, free with krb5_free_keyblock_contents() * * @return Return an error code or 0. * * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_random_to_key ( krb5_context /*context*/, krb5_enctype /*type*/, const void */*data*/, size_t /*size*/, krb5_keyblock */*key*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rc_close ( krb5_context /*context*/, krb5_rcache /*id*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rc_default ( krb5_context /*context*/, krb5_rcache */*id*/); KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL krb5_rc_default_name (krb5_context /*context*/); KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL krb5_rc_default_type (krb5_context /*context*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rc_destroy ( krb5_context /*context*/, krb5_rcache /*id*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rc_expunge ( krb5_context /*context*/, krb5_rcache /*id*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rc_get_lifespan ( krb5_context /*context*/, krb5_rcache /*id*/, krb5_deltat */*auth_lifespan*/); KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL krb5_rc_get_name ( krb5_context /*context*/, krb5_rcache /*id*/); KRB5_LIB_FUNCTION const char* KRB5_LIB_CALL krb5_rc_get_type ( krb5_context /*context*/, krb5_rcache /*id*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rc_initialize ( krb5_context /*context*/, krb5_rcache /*id*/, krb5_deltat /*auth_lifespan*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rc_recover ( krb5_context /*context*/, krb5_rcache /*id*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rc_resolve ( krb5_context /*context*/, krb5_rcache /*id*/, const char */*name*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rc_resolve_full ( krb5_context /*context*/, krb5_rcache */*id*/, const char */*string_name*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rc_resolve_type ( krb5_context /*context*/, krb5_rcache */*id*/, const char */*type*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rc_store ( krb5_context /*context*/, krb5_rcache /*id*/, krb5_donot_replay */*rep*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rd_cred ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_data */*in_data*/, krb5_creds ***/*ret_creds*/, krb5_replay_data */*outdata*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rd_cred2 ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, krb5_ccache /*ccache*/, krb5_data */*in_data*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rd_error ( krb5_context /*context*/, const krb5_data */*msg*/, KRB_ERROR */*result*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rd_priv ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, const krb5_data */*inbuf*/, krb5_data */*outbuf*/, krb5_replay_data */*outdata*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rd_rep ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, const krb5_data */*inbuf*/, krb5_ap_rep_enc_part **/*repl*/); /** * Process an AP_REQ message. * * @param context Kerberos 5 context. * @param auth_context authentication context of the peer. * @param inbuf the AP_REQ message, obtained for example with krb5_read_message(). * @param server server principal. * @param keytab server keytab. * @param ap_req_options set to the AP_REQ options. See the AP_OPTS_* defines. * @param ticket on success, set to the authenticated client credentials. * Must be deallocated with krb5_free_ticket(). If not * interested, pass a NULL value. * * @return 0 to indicate success. Otherwise a Kerberos error code is * returned, see krb5_get_error_message(). */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rd_req ( krb5_context /*context*/, krb5_auth_context */*auth_context*/, const krb5_data */*inbuf*/, krb5_const_principal /*server*/, krb5_keytab /*keytab*/, krb5_flags */*ap_req_options*/, krb5_ticket **/*ticket*/); /** * The core server function that verify application authentication * requests from clients. * * @param context Keberos 5 context. * @param auth_context the authentication context, can be NULL, then * default values for the authentication context will used. * @param inbuf the (AP-REQ) authentication buffer * * @param server the server to authenticate to. If NULL the function * will try to find any available credential in the keytab * that will verify the reply. The function will prefer the * server specified in the AP-REQ, but if * there is no mach, it will try all keytab entries for a * match. This has serious performance issues for large keytabs. * * @param inctx control the behavior of the function, if NULL, the * default behavior is used. * @param outctx the return outctx, free with krb5_rd_req_out_ctx_free(). * @return Kerberos 5 error code, see krb5_get_error_message(). * * @ingroup krb5_auth */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rd_req_ctx ( krb5_context /*context*/, krb5_auth_context */*auth_context*/, const krb5_data */*inbuf*/, krb5_const_principal /*server*/, krb5_rd_req_in_ctx /*inctx*/, krb5_rd_req_out_ctx */*outctx*/); /** * Allocate a krb5_rd_req_in_ctx as an input parameter to * krb5_rd_req_ctx(). The caller should free the context with * krb5_rd_req_in_ctx_free() when done with the context. * * @param context Keberos 5 context. * @param ctx in ctx to krb5_rd_req_ctx(). * * @return Kerberos 5 error code, see krb5_get_error_message(). * * @ingroup krb5_auth */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rd_req_in_ctx_alloc ( krb5_context /*context*/, krb5_rd_req_in_ctx */*ctx*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_rd_req_in_ctx_free ( krb5_context /*context*/, krb5_rd_req_in_ctx /*ctx*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rd_req_in_set_keyblock ( krb5_context /*context*/, krb5_rd_req_in_ctx /*in*/, krb5_keyblock */*keyblock*/); /** * Set the keytab that krb5_rd_req_ctx() will use. * * @param context Keberos 5 context. * @param in in ctx to krb5_rd_req_ctx(). * @param keytab keytab that krb5_rd_req_ctx() will use, only copy the * pointer, so the caller must free they keytab after * krb5_rd_req_in_ctx_free() is called. * * @return Kerberos 5 error code, see krb5_get_error_message(). * * @ingroup krb5_auth */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rd_req_in_set_keytab ( krb5_context /*context*/, krb5_rd_req_in_ctx /*in*/, krb5_keytab /*keytab*/); /** * Set if krb5_rq_red() is going to check the Windows PAC or not * * @param context Keberos 5 context. * @param in krb5_rd_req_in_ctx to check the option on. * @param flag flag to select if to check the pac (TRUE) or not (FALSE). * * @return Kerberos 5 error code, see krb5_get_error_message(). * * @ingroup krb5_auth */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rd_req_in_set_pac_check ( krb5_context /*context*/, krb5_rd_req_in_ctx /*in*/, krb5_boolean /*flag*/); /** * Free the krb5_rd_req_out_ctx. * * @param context Keberos 5 context. * @param ctx krb5_rd_req_out_ctx context to free. * * @ingroup krb5_auth */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_rd_req_out_ctx_free ( krb5_context /*context*/, krb5_rd_req_out_ctx /*ctx*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rd_req_out_get_ap_req_options ( krb5_context /*context*/, krb5_rd_req_out_ctx /*out*/, krb5_flags */*ap_req_options*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rd_req_out_get_keyblock ( krb5_context /*context*/, krb5_rd_req_out_ctx /*out*/, krb5_keyblock **/*keyblock*/); /** * Get the principal that was used in the request from the * client. Might not match whats in the ticket if krb5_rd_req_ctx() * searched in the keytab for a matching key. * * @param context a Kerberos 5 context. * @param out a krb5_rd_req_out_ctx from krb5_rd_req_ctx(). * @param principal return principal, free with krb5_free_principal(). * * @ingroup krb5_auth */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rd_req_out_get_server ( krb5_context /*context*/, krb5_rd_req_out_ctx /*out*/, krb5_principal */*principal*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rd_req_out_get_ticket ( krb5_context /*context*/, krb5_rd_req_out_ctx /*out*/, krb5_ticket **/*ticket*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rd_req_with_keyblock ( krb5_context /*context*/, krb5_auth_context */*auth_context*/, const krb5_data */*inbuf*/, krb5_const_principal /*server*/, krb5_keyblock */*keyblock*/, krb5_flags */*ap_req_options*/, krb5_ticket **/*ticket*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_rd_safe ( krb5_context /*context*/, krb5_auth_context /*auth_context*/, const krb5_data */*inbuf*/, krb5_data */*outbuf*/, krb5_replay_data */*outdata*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_read_message ( krb5_context /*context*/, krb5_pointer /*p_fd*/, krb5_data */*data*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_read_priv_message ( krb5_context /*context*/, krb5_auth_context /*ac*/, krb5_pointer /*p_fd*/, krb5_data */*data*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_read_safe_message ( krb5_context /*context*/, krb5_auth_context /*ac*/, krb5_pointer /*p_fd*/, krb5_data */*data*/); /** * return TRUE iff realm(princ1) == realm(princ2) * * @param context Kerberos 5 context * @param princ1 first principal to compare * @param princ2 second principal to compare * * @ingroup krb5_principal * @see krb5_principal_compare_any_realm() * @see krb5_principal_compare() */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_realm_compare ( krb5_context /*context*/, krb5_const_principal /*princ1*/, krb5_const_principal /*princ2*/); /** * Returns true if name is Kerberos an LKDC realm * * @ingroup krb5_principal */ krb5_boolean KRB5_LIB_FUNCTION krb5_realm_is_lkdc (const char */*realm*/); /** * Perform the server side of the sendauth protocol. * * @param context Kerberos 5 context. * @param auth_context authentication context of the peer. * @param p_fd socket associated to the connection. * @param appl_version server-specific string. * @param server server principal. * @param flags if KRB5_RECVAUTH_IGNORE_VERSION is set, skip the sendauth version * part of the protocol. * @param keytab server keytab. * @param ticket on success, set to the authenticated client credentials. * Must be deallocated with krb5_free_ticket(). If not * interested, pass a NULL value. * * @return 0 to indicate success. Otherwise a Kerberos error code is * returned, see krb5_get_error_message(). */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_recvauth ( krb5_context /*context*/, krb5_auth_context */*auth_context*/, krb5_pointer /*p_fd*/, const char */*appl_version*/, krb5_principal /*server*/, int32_t /*flags*/, krb5_keytab /*keytab*/, krb5_ticket **/*ticket*/); /** * Perform the server side of the sendauth protocol like krb5_recvauth(), but support * a user-specified callback, \a match_appl_version, to perform the match of the application * version \a match_data. */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_recvauth_match_version ( krb5_context /*context*/, krb5_auth_context */*auth_context*/, krb5_pointer /*p_fd*/, krb5_boolean (*/*match_appl_version*/)(const void *, const char*), const void */*match_data*/, krb5_principal /*server*/, int32_t /*flags*/, krb5_keytab /*keytab*/, krb5_ticket **/*ticket*/); /** * Read a address block from the storage. * * @param sp the storage buffer to write to * @param adr the address block read from storage * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_address ( krb5_storage */*sp*/, krb5_address */*adr*/); /** * Read a addresses block from the storage. * * @param sp the storage buffer to write to * @param adr the addresses block read from storage * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_addrs ( krb5_storage */*sp*/, krb5_addresses */*adr*/); /** * Read a auth data from the storage. * * @param sp the storage buffer to write to * @param auth the auth data block read from storage * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_authdata ( krb5_storage */*sp*/, krb5_authdata */*auth*/); /** * Read a credentials block from the storage. * * @param sp the storage buffer to write to * @param creds the credentials block read from storage * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_creds ( krb5_storage */*sp*/, krb5_creds */*creds*/); /** * Read a tagged credentials block from the storage. * * @param sp the storage buffer to write to * @param creds the credentials block read from storage * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_creds_tag ( krb5_storage */*sp*/, krb5_creds */*creds*/); /** * Parse a data from the storage. * * @param sp the storage buffer to read from * @param data the parsed data * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_data ( krb5_storage */*sp*/, krb5_data */*data*/); /** * Read a int16 from storage, byte order is controlled by the settings * on the storage, see krb5_storage_set_byteorder(). * * @param sp the storage to write too * @param value the value read from the buffer * * @return 0 for success, or a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_int16 ( krb5_storage */*sp*/, int16_t */*value*/); /** * Read a int32 from storage, byte order is controlled by the settings * on the storage, see krb5_storage_set_byteorder(). * * @param sp the storage to write too * @param value the value read from the buffer * * @return 0 for success, or a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_int32 ( krb5_storage */*sp*/, int32_t */*value*/); /** * Read a int64 from storage, byte order is controlled by the settings * on the storage, see krb5_storage_set_byteorder(). * * @param sp the storage to write too * @param value the value read from the buffer * * @return 0 for success, or a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_int64 ( krb5_storage */*sp*/, int64_t */*value*/); /** * Read a int8 from storage * * @param sp the storage to write too * @param value the value read from the buffer * * @return 0 for success, or a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_int8 ( krb5_storage */*sp*/, int8_t */*value*/); /** * Read a keyblock from the storage. * * @param sp the storage buffer to write to * @param p the keyblock read from storage, free using krb5_free_keyblock() * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_keyblock ( krb5_storage */*sp*/, krb5_keyblock */*p*/); /** * Parse principal from the storage. * * @param sp the storage buffer to read from * @param princ the parsed principal * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_principal ( krb5_storage */*sp*/, krb5_principal */*princ*/); /** * Parse a string from the storage. * * @param sp the storage buffer to read from * @param string the parsed string * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_string ( krb5_storage */*sp*/, char **/*string*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_stringnl ( krb5_storage */*sp*/, char **/*string*/); /** * Parse zero terminated string from the storage. * * @param sp the storage buffer to read from * @param string the parsed string * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_stringz ( krb5_storage */*sp*/, char **/*string*/); /** * Read a times block from the storage. * * @param sp the storage buffer to write to * @param times the times block read from storage * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_times ( krb5_storage */*sp*/, krb5_times */*times*/); /** * Read a int16 from storage, byte order is controlled by the settings * on the storage, see krb5_storage_set_byteorder(). * * @param sp the storage to write too * @param value the value read from the buffer * * @return 0 for success, or a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_uint16 ( krb5_storage */*sp*/, uint16_t */*value*/); /** * Read a uint32 from storage, byte order is controlled by the settings * on the storage, see krb5_storage_set_byteorder(). * * @param sp the storage to write too * @param value the value read from the buffer * * @return 0 for success, or a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_uint32 ( krb5_storage */*sp*/, uint32_t */*value*/); /** * Read a uint64 from storage, byte order is controlled by the settings * on the storage, see krb5_storage_set_byteorder(). * * @param sp the storage to write too * @param value the value read from the buffer * * @return 0 for success, or a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_uint64 ( krb5_storage */*sp*/, uint64_t */*value*/); /** * Read a uint8 from storage * * @param sp the storage to write too * @param value the value read from the buffer * * @return 0 for success, or a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ret_uint8 ( krb5_storage */*sp*/, uint8_t */*value*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_salttype_to_string ( krb5_context /*context*/, krb5_enctype /*etype*/, krb5_salttype /*stype*/, char **/*string*/); /** * Perform the client side of the sendauth protocol. * * @param context Kerberos 5 context. * @param auth_context Authentication context of the peer. * @param p_fd Socket associated to the connection. * @param appl_version Server-specific string. * @param client Client principal. If NULL, use the credentials in \a ccache. * @param server Server principal. * @param ap_req_options Options for the AP_REQ message. See the AP_OPTS_* defines in krb5.h. * @param in_data FIXME * @param in_creds FIXME * @param ccache Credentials cache. If NULL, use the default credentials cache. * @param ret_error If not NULL, will be set to the error reported by server, if any. * Must be deallocated with krb5_free_error_contents(). * @param rep_result If not NULL, will be set to the EncApRepPart of the AP_REP message. * Must be deallocated with krb5_free_ap_rep_enc_part(). * @param out_creds FIXME If not NULL, will be set to FIXME. Must be deallocated with * krb5_free_creds(). * * @return 0 to indicate success. Otherwise a Kerberos error code is * returned, see krb5_get_error_message(). */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_sendauth ( krb5_context /*context*/, krb5_auth_context */*auth_context*/, krb5_pointer /*p_fd*/, const char */*appl_version*/, krb5_principal /*client*/, krb5_principal /*server*/, krb5_flags /*ap_req_options*/, krb5_data */*in_data*/, krb5_creds */*in_creds*/, krb5_ccache /*ccache*/, krb5_error **/*ret_error*/, krb5_ap_rep_enc_part **/*rep_result*/, krb5_creds **/*out_creds*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_sendto ( krb5_context /*context*/, const krb5_data */*send_data*/, krb5_krbhst_handle /*handle*/, krb5_data */*receive*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_sendto_context ( krb5_context /*context*/, krb5_sendto_ctx /*ctx*/, const krb5_data */*send_data*/, krb5_const_realm /*realm*/, krb5_data */*receive*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_sendto_ctx_add_flags ( krb5_sendto_ctx /*ctx*/, int /*flags*/); /** * @section send_to_kdc Locating and sending packets to the KDC * * The send to kdc code is responsible to request the list of KDC from * the locate-kdc subsystem and then send requests to each of them. * * - Each second a new hostname is tried. * - If the hostname have several addresses, the first will be tried * directly then in turn the other will be tried every 3 seconds * (host_timeout). * - UDP requests are tried 3 times, and it tried with a individual timeout of kdc_timeout / 3. * - TCP and HTTP requests are tried 1 time. * * Total wait time shorter then (number of addresses * 3) + kdc_timeout seconds. * */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_sendto_ctx_alloc ( krb5_context /*context*/, krb5_sendto_ctx */*ctx*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_sendto_ctx_free ( krb5_context /*context*/, krb5_sendto_ctx /*ctx*/); KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_sendto_ctx_get_flags (krb5_sendto_ctx /*ctx*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_sendto_ctx_set_func ( krb5_sendto_ctx /*ctx*/, krb5_sendto_ctx_func /*func*/, void */*data*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_sendto_ctx_set_type ( krb5_sendto_ctx /*ctx*/, int /*type*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_sendto_kdc ( krb5_context /*context*/, const krb5_data */*send_data*/, const krb5_realm */*realm*/, krb5_data */*receive*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_sendto_kdc_flags ( krb5_context /*context*/, const krb5_data */*send_data*/, const krb5_realm */*realm*/, krb5_data */*receive*/, int /*flags*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_sendto_set_hostname ( krb5_context /*context*/, krb5_sendto_ctx /*ctx*/, const char */*hostname*/); /** * Reinit the context from a new set of filenames. * * @param context context to add configuration too. * @param filenames array of filenames, end of list is indicated with a NULL filename. * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_set_config_files ( krb5_context /*context*/, char **/*filenames*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_set_debug_dest ( krb5_context /*context*/, const char */*program*/, const char */*log_spec*/); /** * Set the default encryption types that will be use in communcation * with the KDC, clients and servers. * * @param context Kerberos 5 context. * @param etypes Encryption types, array terminated with ETYPE_NULL (0). * A value of NULL resets the encryption types to the defaults set in the * configuration file. * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_set_default_in_tkt_etypes ( krb5_context /*context*/, const krb5_enctype */*etypes*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_set_default_realm ( krb5_context /*context*/, const char */*realm*/); /** * Set if the library should use DNS to canonicalize hostnames. * * @param context Kerberos 5 context. * @param flag if its dns canonicalizion is used or not. * * @ingroup krb5 */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_set_dns_canonicalize_hostname ( krb5_context /*context*/, krb5_boolean /*flag*/); /** * Set the context full error string for a specific error code. * The error that is stored should be internationalized. * * The if context is NULL, no error string is stored. * * @param context Kerberos 5 context * @param ret The error code * @param fmt Error string for the error code * @param ... printf(3) style parameters. * * @ingroup krb5_error */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_set_error_message ( krb5_context /*context*/, krb5_error_code /*ret*/, const char */*fmt*/, ...) __attribute__ ((__format__ (__printf__, 3, 4))); /** * Set the error message returned by krb5_get_error_string(). * * Deprecated: use krb5_get_error_message() * * @param context Kerberos context * @param fmt error message to free * * @return Return an error code or 0. * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_set_error_string ( krb5_context /*context*/, const char */*fmt*/, ...) __attribute__ ((__format__ (__printf__, 2, 3))) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Set extra address to the address list that the library will add to * the client's address list when communicating with the KDC. * * @param context Kerberos 5 context. * @param addresses addreses to set * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_set_extra_addresses ( krb5_context /*context*/, const krb5_addresses */*addresses*/); /** * Set version of fcache that the library should use. * * @param context Kerberos 5 context. * @param version version number. * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_set_fcache_version ( krb5_context /*context*/, int /*version*/); /** * Enable and disable home directory access on either the global state * or the krb5_context state. By calling krb5_set_home_dir_access() * with context set to NULL, the global state is configured otherwise * the state for the krb5_context is modified. * * For home directory access to be allowed, both the global state and * the krb5_context state have to be allowed. * * @param context a Kerberos 5 context or NULL * @param allow allow if TRUE home directory * @return the old value * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_set_home_dir_access ( krb5_context /*context*/, krb5_boolean /*allow*/); /** * Set extra addresses to ignore when fetching addresses from the * underlaying operating system. * * @param context Kerberos 5 context. * @param addresses addreses to ignore * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_set_ignore_addresses ( krb5_context /*context*/, const krb5_addresses */*addresses*/); /** * Set current offset in time to the KDC. * * @param context Kerberos 5 context. * @param sec seconds part of offset. * @param usec micro seconds part of offset. * * @return returns zero * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_set_kdc_sec_offset ( krb5_context /*context*/, int32_t /*sec*/, int32_t /*usec*/); /** * Set max time skew allowed. * * @param context Kerberos 5 context. * @param t timeskew in seconds. * * @ingroup krb5 */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_set_max_time_skew ( krb5_context /*context*/, time_t /*t*/); /** * Change password using creds. * * @param context a Keberos context * @param creds The initial kadmin/passwd for the principal or an admin principal * @param newpw The new password to set * @param targprinc if unset, the default principal is used. * @param result_code Result code, KRB5_KPASSWD_SUCCESS is when password is changed. * @param result_code_string binary message from the server, contains * at least the result_code. * @param result_string A message from the kpasswd service or the * library in human printable form. The string is NUL terminated. * * @return On sucess and *result_code is KRB5_KPASSWD_SUCCESS, the password is changed. * @ingroup @krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_set_password ( krb5_context /*context*/, krb5_creds */*creds*/, const char */*newpw*/, krb5_principal /*targprinc*/, int */*result_code*/, krb5_data */*result_code_string*/, krb5_data */*result_string*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_set_password_using_ccache ( krb5_context /*context*/, krb5_ccache /*ccache*/, const char */*newpw*/, krb5_principal /*targprinc*/, int */*result_code*/, krb5_data */*result_code_string*/, krb5_data */*result_string*/); /** * Set the absolute time that the caller knows the kdc has so the * kerberos library can calculate the relative diffrence beteen the * KDC time and local system time. * * @param context Keberos 5 context. * @param sec The applications new of "now" in seconds * @param usec The applications new of "now" in micro seconds * @return Kerberos 5 error code, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_set_real_time ( krb5_context /*context*/, krb5_timestamp /*sec*/, int32_t /*usec*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_set_send_to_kdc_func ( krb5_context /*context*/, krb5_send_to_kdc_func /*func*/, void */*data*/); /** * Make the kerberos library default to the admin KDC. * * @param context Kerberos 5 context. * @param flag boolean flag to select if the use the admin KDC or not. * * @ingroup krb5 */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_set_use_admin_kdc ( krb5_context /*context*/, krb5_boolean /*flag*/); /** * Set the default logging facility. * * @param context A Kerberos 5 context * @param fac Facility to use for logging. * * @ingroup krb5_error */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_set_warn_dest ( krb5_context /*context*/, krb5_log_facility */*fac*/); /** * Create a principal for the given service running on the given * hostname. If KRB5_NT_SRV_HST is used, the hostname is canonicalized * according the configured name canonicalization rules, with * canonicalization delayed in some cases. One rule involves DNS, which * is insecure unless DNSSEC is used, but we don't use DNSSEC-capable * resolver APIs here, so that if DNSSEC is used we wouldn't know it. * * Canonicalization is immediate (not delayed) only when there is only * one canonicalization rule and that rule indicates that we should do a * host lookup by name (i.e., DNS). * * @param context A Kerberos context. * @param hostname hostname to use * @param sname Service name to use * @param type name type of principal, use KRB5_NT_SRV_HST or KRB5_NT_UNKNOWN. * @param ret_princ return principal, free with krb5_free_principal(). * * @return An krb5 error code, see krb5_get_error_message(). * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_sname_to_principal ( krb5_context /*context*/, const char */*hostname*/, const char */*sname*/, int32_t /*type*/, krb5_principal */*ret_princ*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_sock_to_principal ( krb5_context /*context*/, int /*sock*/, const char */*sname*/, int32_t /*type*/, krb5_principal */*ret_princ*/); /** * krb5_sockaddr2address stores a address a "struct sockaddr" sa in * the krb5_address addr. * * @param context a Keberos context * @param sa a struct sockaddr to extract the address from * @param addr an Kerberos 5 address to store the address in. * * @return Return an error code or 0. * * @ingroup krb5_address */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_sockaddr2address ( krb5_context /*context*/, const struct sockaddr */*sa*/, krb5_address */*addr*/); /** * krb5_sockaddr2port extracts a port (if possible) from a "struct * sockaddr. * * @param context a Keberos context * @param sa a struct sockaddr to extract the port from * @param port a pointer to an int16_t store the port in. * * @return Return an error code or 0. Will return * KRB5_PROG_ATYPE_NOSUPP in case address type is not supported. * * @ingroup krb5_address */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_sockaddr2port ( krb5_context /*context*/, const struct sockaddr */*sa*/, int16_t */*port*/); KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_sockaddr_is_loopback (const struct sockaddr */*sa*/); /** * krb5_sockaddr_uninteresting returns TRUE for all .Fa sa that the * kerberos library thinks are uninteresting. One example are link * local addresses. * * @param sa pointer to struct sockaddr that might be interesting. * * @return Return a non zero for uninteresting addresses. * * @ingroup krb5_address */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_sockaddr_uninteresting (const struct sockaddr */*sa*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_std_usage ( int /*code*/, struct getargs */*args*/, int /*num_args*/); /** * Clear the flags on a storage buffer * * @param sp the storage buffer to clear the flags on * @param flags the flags to clear * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_storage_clear_flags ( krb5_storage */*sp*/, krb5_flags /*flags*/); /** * Create a elastic (allocating) memory storage backend. Memory is * allocated on demand. Free returned krb5_storage with * krb5_storage_free(). * * @return A krb5_storage on success, or NULL on out of memory error. * * @ingroup krb5_storage * * @sa krb5_storage_from_mem() * @sa krb5_storage_from_readonly_mem() * @sa krb5_storage_from_fd() * @sa krb5_storage_from_data() * @sa krb5_storage_from_socket() */ KRB5_LIB_FUNCTION krb5_storage * KRB5_LIB_CALL krb5_storage_emem (void); /** * Free a krb5 storage. * * @param sp the storage to free. * * @return An Kerberos 5 error code. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_storage_free (krb5_storage */*sp*/); /** * Create a fixed size memory storage block * * @return A krb5_storage on success, or NULL on out of memory error. * * @ingroup krb5_storage * * @sa krb5_storage_mem() * @sa krb5_storage_from_mem() * @sa krb5_storage_from_readonly_mem() * @sa krb5_storage_from_fd() */ KRB5_LIB_FUNCTION krb5_storage * KRB5_LIB_CALL krb5_storage_from_data (krb5_data */*data*/); /** * * * @return A krb5_storage on success, or NULL on out of memory error. * * @ingroup krb5_storage * * @sa krb5_storage_emem() * @sa krb5_storage_from_mem() * @sa krb5_storage_from_readonly_mem() * @sa krb5_storage_from_data() * @sa krb5_storage_from_socket() */ KRB5_LIB_FUNCTION krb5_storage * KRB5_LIB_CALL krb5_storage_from_fd (int /*fd_in*/); /** * Create a fixed size memory storage block * * @return A krb5_storage on success, or NULL on out of memory error. * * @ingroup krb5_storage * * @sa krb5_storage_mem() * @sa krb5_storage_from_readonly_mem() * @sa krb5_storage_from_data() * @sa krb5_storage_from_fd() * @sa krb5_storage_from_socket() */ KRB5_LIB_FUNCTION krb5_storage * KRB5_LIB_CALL krb5_storage_from_mem ( void */*buf*/, size_t /*len*/); /** * Create a fixed size memory storage block that is read only * * @return A krb5_storage on success, or NULL on out of memory error. * * @ingroup krb5_storage * * @sa krb5_storage_mem() * @sa krb5_storage_from_mem() * @sa krb5_storage_from_data() * @sa krb5_storage_from_fd() */ KRB5_LIB_FUNCTION krb5_storage * KRB5_LIB_CALL krb5_storage_from_readonly_mem ( const void */*buf*/, size_t /*len*/); /** * * * @return A krb5_storage on success, or NULL on out of memory error. * * @ingroup krb5_storage * * @sa krb5_storage_emem() * @sa krb5_storage_from_mem() * @sa krb5_storage_from_readonly_mem() * @sa krb5_storage_from_data() * @sa krb5_storage_from_fd() */ KRB5_LIB_FUNCTION krb5_storage * KRB5_LIB_CALL krb5_storage_from_socket (krb5_socket_t /*sock_in*/); /** * Sync the storage buffer to its backing store. If there is no * backing store this function will return success. * * @param sp the storage buffer to sync * * @return A Kerberos 5 error code * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_storage_fsync (krb5_storage */*sp*/); /** * Return the current byteorder for the buffer. See krb5_storage_set_byteorder() for the list or byte order contants. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_flags KRB5_LIB_CALL krb5_storage_get_byteorder (krb5_storage */*sp*/); /** * Get the return code that will be used when end of storage is reached. * * @param sp the storage * * @return storage error code * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_storage_get_eof_code (krb5_storage */*sp*/); /** * Return true or false depending on if the storage flags is set or * not. NB testing for the flag 0 always return true. * * @param sp the storage buffer to check flags on * @param flags The flags to test for * * @return true if all the flags are set, false if not. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_boolean KRB5_LIB_CALL krb5_storage_is_flags ( krb5_storage */*sp*/, krb5_flags /*flags*/); /** * Read to the storage buffer. * * @param sp the storage buffer to read from * @param buf the buffer to store the data in * @param len the length to read * * @return The length of data read (can be shorter then len), or negative on error. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_ssize_t KRB5_LIB_CALL krb5_storage_read ( krb5_storage */*sp*/, void */*buf*/, size_t /*len*/); /** * Seek to a new offset. * * @param sp the storage buffer to seek in. * @param offset the offset to seek * @param whence relateive searching, SEEK_CUR from the current * position, SEEK_END from the end, SEEK_SET absolute from the start. * * @return The new current offset * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION off_t KRB5_LIB_CALL krb5_storage_seek ( krb5_storage */*sp*/, off_t /*offset*/, int /*whence*/); /** * Set the new byte order of the storage buffer. * * @param sp the storage buffer to set the byte order for. * @param byteorder the new byte order. * * The byte order are: KRB5_STORAGE_BYTEORDER_BE, * KRB5_STORAGE_BYTEORDER_LE and KRB5_STORAGE_BYTEORDER_HOST. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_storage_set_byteorder ( krb5_storage */*sp*/, krb5_flags /*byteorder*/); /** * Set the return code that will be used when end of storage is reached. * * @param sp the storage * @param code the error code to return on end of storage * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_storage_set_eof_code ( krb5_storage */*sp*/, int /*code*/); /** * Add the flags on a storage buffer by or-ing in the flags to the buffer. * * @param sp the storage buffer to set the flags on * @param flags the flags to set * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_storage_set_flags ( krb5_storage */*sp*/, krb5_flags /*flags*/); /** * Set the max alloc value * * @param sp the storage buffer set the max allow for * @param size maximum size to allocate, use 0 to remove limit * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_storage_set_max_alloc ( krb5_storage */*sp*/, size_t /*size*/); /** * Copy the contnent of storage * * @param sp the storage to copy to a data * @param data the copied data, free with krb5_data_free() * * @return 0 for success, or a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_storage_to_data ( krb5_storage */*sp*/, krb5_data */*data*/); /** * Truncate the storage buffer in sp to offset. * * @param sp the storage buffer to truncate. * @param offset the offset to truncate too. * * @return An Kerberos 5 error code. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_storage_truncate ( krb5_storage */*sp*/, off_t /*offset*/); /** * Write to the storage buffer. * * @param sp the storage buffer to write to * @param buf the buffer to write to the storage buffer * @param len the length to write * * @return The length of data written (can be shorter then len), or negative on error. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_ssize_t KRB5_LIB_CALL krb5_storage_write ( krb5_storage */*sp*/, const void */*buf*/, size_t /*len*/); /** * Write a address block to storage. * * @param sp the storage buffer to write to * @param p the address block to write. * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_address ( krb5_storage */*sp*/, krb5_address /*p*/); /** * Write a addresses block to storage. * * @param sp the storage buffer to write to * @param p the addresses block to write. * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_addrs ( krb5_storage */*sp*/, krb5_addresses /*p*/); /** * Write a auth data block to storage. * * @param sp the storage buffer to write to * @param auth the auth data block to write. * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_authdata ( krb5_storage */*sp*/, krb5_authdata /*auth*/); /** * Write a credentials block to storage. * * @param sp the storage buffer to write to * @param creds the creds block to write. * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_creds ( krb5_storage */*sp*/, krb5_creds */*creds*/); /** * Write a tagged credentials block to storage. * * @param sp the storage buffer to write to * @param creds the creds block to write. * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_creds_tag ( krb5_storage */*sp*/, krb5_creds */*creds*/); /** * Store a data to the storage. The data is stored with an int32 as * lenght plus the data (not padded). * * @param sp the storage buffer to write to * @param data the buffer to store. * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_data ( krb5_storage */*sp*/, krb5_data /*data*/); /** * Store a int16 to storage, byte order is controlled by the settings * on the storage, see krb5_storage_set_byteorder(). * * @param sp the storage to write too * @param value the value to store * * @return 0 for success, or a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_int16 ( krb5_storage */*sp*/, int16_t /*value*/); /** * Store a int32 to storage, byte order is controlled by the settings * on the storage, see krb5_storage_set_byteorder(). * * @param sp the storage to write too * @param value the value to store * * @return 0 for success, or a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_int32 ( krb5_storage */*sp*/, int32_t /*value*/); /** * Store a int64 to storage, byte order is controlled by the settings * on the storage, see krb5_storage_set_byteorder(). * * @param sp the storage to write too * @param value the value to store * * @return 0 for success, or a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_int64 ( krb5_storage */*sp*/, int64_t /*value*/); /** * Store a int8 to storage. * * @param sp the storage to write too * @param value the value to store * * @return 0 for success, or a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_int8 ( krb5_storage */*sp*/, int8_t /*value*/); /** * Store a keyblock to the storage. * * @param sp the storage buffer to write to * @param p the keyblock to write * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_keyblock ( krb5_storage */*sp*/, krb5_keyblock /*p*/); /** * Write a principal block to storage. * * @param sp the storage buffer to write to * @param p the principal block to write. * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_principal ( krb5_storage */*sp*/, krb5_const_principal /*p*/); /** * Store a string to the buffer. The data is formated as an len:uint32 * plus the string itself (not padded). * * @param sp the storage buffer to write to * @param s the string to store. * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_string ( krb5_storage */*sp*/, const char */*s*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_stringnl ( krb5_storage */*sp*/, const char */*s*/); /** * Store a zero terminated string to the buffer. The data is stored * one character at a time until a NUL is stored. * * @param sp the storage buffer to write to * @param s the string to store. * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_stringz ( krb5_storage */*sp*/, const char */*s*/); /** * Write a times block to storage. * * @param sp the storage buffer to write to * @param times the times block to write. * * @return 0 on success, a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_times ( krb5_storage */*sp*/, krb5_times /*times*/); /** * Store a uint16 to storage, byte order is controlled by the settings * on the storage, see krb5_storage_set_byteorder(). * * @param sp the storage to write too * @param value the value to store * * @return 0 for success, or a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_uint16 ( krb5_storage */*sp*/, uint16_t /*value*/); /** * Store a uint32 to storage, byte order is controlled by the settings * on the storage, see krb5_storage_set_byteorder(). * * @param sp the storage to write too * @param value the value to store * * @return 0 for success, or a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_uint32 ( krb5_storage */*sp*/, uint32_t /*value*/); /** * Store a uint64 to storage, byte order is controlled by the settings * on the storage, see krb5_storage_set_byteorder(). * * @param sp the storage to write too * @param value the value to store * * @return 0 for success, or a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_uint64 ( krb5_storage */*sp*/, uint64_t /*value*/); /** * Store a uint8 to storage. * * @param sp the storage to write too * @param value the value to store * * @return 0 for success, or a Kerberos 5 error code on failure. * * @ingroup krb5_storage */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_store_uint8 ( krb5_storage */*sp*/, uint8_t /*value*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_string_to_deltat ( const char */*string*/, krb5_deltat */*deltat*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_string_to_enctype ( krb5_context /*context*/, const char */*string*/, krb5_enctype */*etype*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_string_to_key ( krb5_context /*context*/, krb5_enctype /*enctype*/, const char */*password*/, krb5_principal /*principal*/, krb5_keyblock */*key*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_string_to_key_data ( krb5_context /*context*/, krb5_enctype /*enctype*/, krb5_data /*password*/, krb5_principal /*principal*/, krb5_keyblock */*key*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_string_to_key_data_salt ( krb5_context /*context*/, krb5_enctype /*enctype*/, krb5_data /*password*/, krb5_salt /*salt*/, krb5_keyblock */*key*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_string_to_key_data_salt_opaque ( krb5_context /*context*/, krb5_enctype /*enctype*/, krb5_data /*password*/, krb5_salt /*salt*/, krb5_data /*opaque*/, krb5_keyblock */*key*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_string_to_key_derived ( krb5_context /*context*/, const void */*str*/, size_t /*len*/, krb5_enctype /*etype*/, krb5_keyblock */*key*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_string_to_key_salt ( krb5_context /*context*/, krb5_enctype /*enctype*/, const char */*password*/, krb5_salt /*salt*/, krb5_keyblock */*key*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_string_to_key_salt_opaque ( krb5_context /*context*/, krb5_enctype /*enctype*/, const char */*password*/, krb5_salt /*salt*/, krb5_data /*opaque*/, krb5_keyblock */*key*/); /** * Deprecated: keytypes doesn't exists, they are really enctypes in * most cases, use krb5_string_to_enctype(). * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_string_to_keytype ( krb5_context /*context*/, const char */*string*/, krb5_keytype */*keytype*/) KRB5_DEPRECATED_FUNCTION("Use X instead"); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_string_to_salttype ( krb5_context /*context*/, krb5_enctype /*etype*/, const char */*string*/, krb5_salttype */*salttype*/); /** * Extract the authorization data type of type from the ticket. Store * the field in data. This function is to use for kerberos * applications. * * @param context a Kerberos 5 context * @param ticket Kerberos ticket * @param type type to fetch * @param data returned data, free with krb5_data_free() * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ticket_get_authorization_data_type ( krb5_context /*context*/, krb5_ticket */*ticket*/, int /*type*/, krb5_data */*data*/); /** * Return client principal in ticket * * @param context a Kerberos 5 context * @param ticket ticket to copy * @param client client principal, free with krb5_free_principal() * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ticket_get_client ( krb5_context /*context*/, const krb5_ticket */*ticket*/, krb5_principal */*client*/); /** * Return end time of ticket * * @param context a Kerberos 5 context * @param ticket ticket to copy * * @return end time of ticket * * @ingroup krb5 */ KRB5_LIB_FUNCTION time_t KRB5_LIB_CALL krb5_ticket_get_endtime ( krb5_context /*context*/, const krb5_ticket */*ticket*/); /** * Get the flags from the Kerberos ticket * * @param context Kerberos context * @param ticket Kerberos ticket * * @return ticket flags * * @ingroup krb5_ticket */ KRB5_LIB_FUNCTION unsigned long KRB5_LIB_CALL krb5_ticket_get_flags ( krb5_context /*context*/, const krb5_ticket */*ticket*/); /** * Return server principal in ticket * * @param context a Kerberos 5 context * @param ticket ticket to copy * @param server server principal, free with krb5_free_principal() * * @return Returns 0 to indicate success. Otherwise an kerberos et * error code is returned, see krb5_get_error_message(). * * @ingroup krb5 */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_ticket_get_server ( krb5_context /*context*/, const krb5_ticket */*ticket*/, krb5_principal */*server*/); /** * If the caller passes in a negative usec, its assumed to be * unknown and the function will use the current time usec. */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_timeofday ( krb5_context /*context*/, krb5_timestamp */*timeret*/); /** * Unparse the Kerberos name into a string * * @param context Kerberos 5 context * @param principal principal to query * @param name resulting string, free with krb5_xfree() * * @return An krb5 error code, see krb5_get_error_message(). * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_unparse_name ( krb5_context /*context*/, krb5_const_principal /*principal*/, char **/*name*/); /** * Unparse the principal name to a fixed buffer * * @param context A Kerberos context. * @param principal principal to unparse * @param name buffer to write name to * @param len length of buffer * * @return An krb5 error code, see krb5_get_error_message(). * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_unparse_name_fixed ( krb5_context /*context*/, krb5_const_principal /*principal*/, char */*name*/, size_t /*len*/); /** * Unparse the principal name with unparse flags to a fixed buffer. * * @param context A Kerberos context. * @param principal principal to unparse * @param flags unparse flags * @param name buffer to write name to * @param len length of buffer * * @return An krb5 error code, see krb5_get_error_message(). * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_unparse_name_fixed_flags ( krb5_context /*context*/, krb5_const_principal /*principal*/, int /*flags*/, char */*name*/, size_t /*len*/); /** * Unparse the principal name to a fixed buffer. The realm is skipped * if its a default realm. * * @param context A Kerberos context. * @param principal principal to unparse * @param name buffer to write name to * @param len length of buffer * * @return An krb5 error code, see krb5_get_error_message(). * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_unparse_name_fixed_short ( krb5_context /*context*/, krb5_const_principal /*principal*/, char */*name*/, size_t /*len*/); /** * Unparse the Kerberos name into a string * * @param context Kerberos 5 context * @param principal principal to query * @param flags flag to determine the behavior * @param name resulting string, free with krb5_xfree() * * @return An krb5 error code, see krb5_get_error_message(). * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_unparse_name_flags ( krb5_context /*context*/, krb5_const_principal /*principal*/, int /*flags*/, char **/*name*/); /** * Unparse the principal name to a allocated buffer. The realm is * skipped if its a default realm. * * @param context A Kerberos context. * @param principal principal to unparse * @param name returned buffer, free with krb5_xfree() * * @return An krb5 error code, see krb5_get_error_message(). * * @ingroup krb5_principal */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_unparse_name_short ( krb5_context /*context*/, krb5_const_principal /*principal*/, char **/*name*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_us_timeofday ( krb5_context /*context*/, krb5_timestamp */*sec*/, int32_t */*usec*/); /** * Log a warning to the log, default stderr, include bthe error from * the last failure and then abort. * * @param context A Kerberos 5 context * @param code error code of the last error * @param fmt message to print * @param ap arguments * * @ingroup krb5_error */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_vabort ( krb5_context /*context*/, krb5_error_code /*code*/, const char */*fmt*/, va_list /*ap*/) __attribute__ ((__noreturn__, __format__ (__printf__, 3, 0))); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_vabortx ( krb5_context /*context*/, const char */*fmt*/, va_list /*ap*/) __attribute__ ((__noreturn__, __format__ (__printf__, 2, 0))); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_verify_ap_req ( krb5_context /*context*/, krb5_auth_context */*auth_context*/, krb5_ap_req */*ap_req*/, krb5_const_principal /*server*/, krb5_keyblock */*keyblock*/, krb5_flags /*flags*/, krb5_flags */*ap_req_options*/, krb5_ticket **/*ticket*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_verify_ap_req2 ( krb5_context /*context*/, krb5_auth_context */*auth_context*/, krb5_ap_req */*ap_req*/, krb5_const_principal /*server*/, krb5_keyblock */*keyblock*/, krb5_flags /*flags*/, krb5_flags */*ap_req_options*/, krb5_ticket **/*ticket*/, krb5_key_usage /*usage*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_verify_authenticator_checksum ( krb5_context /*context*/, krb5_auth_context /*ac*/, void */*data*/, size_t /*len*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_verify_checksum ( krb5_context /*context*/, krb5_crypto /*crypto*/, krb5_key_usage /*usage*/, void */*data*/, size_t /*len*/, Checksum */*cksum*/); /** * Verify a Kerberos message checksum. * * @param context Kerberos context * @param crypto Kerberos crypto context * @param usage Key usage for this buffer * @param data array of buffers to process * @param num_data length of array * @param type return checksum type if not NULL * * @return Return an error code or 0. * @ingroup krb5_crypto */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_verify_checksum_iov ( krb5_context /*context*/, krb5_crypto /*crypto*/, unsigned /*usage*/, krb5_crypto_iov */*data*/, unsigned int /*num_data*/, krb5_cksumtype */*type*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_verify_init_creds ( krb5_context /*context*/, krb5_creds */*creds*/, krb5_principal /*ap_req_server*/, krb5_keytab /*ap_req_keytab*/, krb5_ccache */*ccache*/, krb5_verify_init_creds_opt */*options*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_verify_init_creds_opt_init (krb5_verify_init_creds_opt */*options*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_verify_init_creds_opt_set_ap_req_nofail ( krb5_verify_init_creds_opt */*options*/, int /*ap_req_nofail*/); KRB5_LIB_FUNCTION int KRB5_LIB_CALL krb5_verify_opt_alloc ( krb5_context /*context*/, krb5_verify_opt **/*opt*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_verify_opt_free (krb5_verify_opt */*opt*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_verify_opt_init (krb5_verify_opt */*opt*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_verify_opt_set_ccache ( krb5_verify_opt */*opt*/, krb5_ccache /*ccache*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_verify_opt_set_flags ( krb5_verify_opt */*opt*/, unsigned int /*flags*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_verify_opt_set_keytab ( krb5_verify_opt */*opt*/, krb5_keytab /*keytab*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_verify_opt_set_secure ( krb5_verify_opt */*opt*/, krb5_boolean /*secure*/); KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_verify_opt_set_service ( krb5_verify_opt */*opt*/, const char */*service*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_verify_user ( krb5_context /*context*/, krb5_principal /*principal*/, krb5_ccache /*ccache*/, const char */*password*/, krb5_boolean /*secure*/, const char */*service*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_verify_user_lrealm ( krb5_context /*context*/, krb5_principal /*principal*/, krb5_ccache /*ccache*/, const char */*password*/, krb5_boolean /*secure*/, const char */*service*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_verify_user_opt ( krb5_context /*context*/, krb5_principal /*principal*/, const char */*password*/, krb5_verify_opt */*opt*/); /** * Log a warning to the log, default stderr, include bthe error from * the last failure and then exit. * * @param context A Kerberos 5 context * @param eval the exit code to exit with * @param code error code of the last error * @param fmt message to print * @param ap arguments * * @ingroup krb5_error */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_verr ( krb5_context /*context*/, int /*eval*/, krb5_error_code /*code*/, const char */*fmt*/, va_list /*ap*/) __attribute__ ((__noreturn__, __format__ (__printf__, 4, 0))); /** * Log a warning to the log, default stderr, and then exit. * * @param context A Kerberos 5 context * @param eval the exit code to exit with * @param fmt message to print * @param ap arguments * * @ingroup krb5_error */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_verrx ( krb5_context /*context*/, int /*eval*/, const char */*fmt*/, va_list /*ap*/) __attribute__ ((__noreturn__, __format__ (__printf__, 3, 0))); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_vlog ( krb5_context /*context*/, krb5_log_facility */*fac*/, int /*level*/, const char */*fmt*/, va_list /*ap*/) __attribute__ ((__format__ (__printf__, 4, 0))); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_vlog_msg ( krb5_context /*context*/, krb5_log_facility */*fac*/, char **/*reply*/, int /*level*/, const char */*fmt*/, va_list /*ap*/) __attribute__ ((__format__ (__printf__, 5, 0))); /** * Prepend the contexts's full error string for a specific error code. * * The if context is NULL, no error string is stored. * * @param context Kerberos 5 context * @param ret The error code * @param fmt Error string for the error code * @param args printf(3) style parameters. * * @ingroup krb5_error */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_vprepend_error_message ( krb5_context /*context*/, krb5_error_code /*ret*/, const char */*fmt*/, va_list /*args*/) __attribute__ ((__format__ (__printf__, 3, 0))); /** * Set the context full error string for a specific error code. * * The if context is NULL, no error string is stored. * * @param context Kerberos 5 context * @param ret The error code * @param fmt Error string for the error code * @param args printf(3) style parameters. * * @ingroup krb5_error */ KRB5_LIB_FUNCTION void KRB5_LIB_CALL krb5_vset_error_message ( krb5_context /*context*/, krb5_error_code /*ret*/, const char */*fmt*/, va_list /*args*/) __attribute__ ((__format__ (__printf__, 3, 0))); /** * Set the error message returned by krb5_get_error_string(), * deprecated, use krb5_set_error_message(). * * Deprecated: use krb5_vset_error_message() * * @param context Kerberos context * @param fmt error message to free * @param args variable argument list vector * * @return Return an error code or 0. * * @ingroup krb5_deprecated */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_vset_error_string ( krb5_context /*context*/, const char */*fmt*/, va_list /*args*/) __attribute__ ((__format__ (__printf__, 2, 0))) KRB5_DEPRECATED_FUNCTION("Use X instead"); /** * Log a warning to the log, default stderr, include the error from * the last failure. * * @param context A Kerberos 5 context. * @param code error code of the last error * @param fmt message to print * @param ap arguments * * @ingroup krb5_error */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_vwarn ( krb5_context /*context*/, krb5_error_code /*code*/, const char */*fmt*/, va_list /*ap*/) __attribute__ ((__format__ (__printf__, 3, 0))); /** * Log a warning to the log, default stderr. * * @param context A Kerberos 5 context. * @param fmt message to print * @param ap arguments * * @ingroup krb5_error */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_vwarnx ( krb5_context /*context*/, const char */*fmt*/, va_list /*ap*/) __attribute__ ((__format__ (__printf__, 2, 0))); /** * Log a warning to the log, default stderr, include the error from * the last failure. * * @param context A Kerberos 5 context. * @param code error code of the last error * @param fmt message to print * * @ingroup krb5_error */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_warn ( krb5_context /*context*/, krb5_error_code /*code*/, const char */*fmt*/, ...) __attribute__ ((__format__ (__printf__, 3, 4))); /** * Log a warning to the log, default stderr. * * @param context A Kerberos 5 context. * @param fmt message to print * * @ingroup krb5_error */ KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_warnx ( krb5_context /*context*/, const char */*fmt*/, ...) __attribute__ ((__format__ (__printf__, 2, 3))); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_write_message ( krb5_context /*context*/, krb5_pointer /*p_fd*/, krb5_data */*data*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_write_priv_message ( krb5_context /*context*/, krb5_auth_context /*ac*/, krb5_pointer /*p_fd*/, krb5_data */*data*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_write_safe_message ( krb5_context /*context*/, krb5_auth_context /*ac*/, krb5_pointer /*p_fd*/, krb5_data */*data*/); KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL krb5_xfree (void */*ptr*/); #ifdef __cplusplus } #endif #undef KRB5_DEPRECATED_FUNCTION #endif /* DOXY */ #endif /* __krb5_protos_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/krb5-types.h000066400000000000000000000033161505521762700227750ustar00rootroot00000000000000#ifndef __krb5_types_h__ #define __krb5_types_h__ #include #include #include typedef socklen_t krb5_socklen_t; #include typedef ssize_t krb5_ssize_t; typedef int krb5_socket_t; #if !defined(__has_extension) #define __has_extension(x) 0 #endif #ifndef KRB5TYPES_REQUIRE_GNUC #define KRB5TYPES_REQUIRE_GNUC(m,n,p) \ (((__GNUC__ * 10000) + (__GNUC_MINOR__ * 100) + __GNUC_PATCHLEVEL__) >= \ (((m) * 10000) + ((n) * 100) + (p))) #endif #ifndef HEIMDAL_DEPRECATED #if __has_extension(deprecated) || KRB5TYPES_REQUIRE_GNUC(3,1,0) #define HEIMDAL_DEPRECATED __attribute__ ((__deprecated__)) #elif defined(_MSC_VER) && (_MSC_VER>1200) #define HEIMDAL_DEPRECATED __declspec(deprecated) #else #define HEIMDAL_DEPRECATED #endif #endif #ifndef HEIMDAL_PRINTF_ATTRIBUTE #if __has_extension(format) || KRB5TYPES_REQUIRE_GNUC(3,1,0) #define HEIMDAL_PRINTF_ATTRIBUTE(x) __attribute__ ((__format__ x)) #else #define HEIMDAL_PRINTF_ATTRIBUTE(x) #endif #endif #ifndef HEIMDAL_NORETURN_ATTRIBUTE #if __has_extension(noreturn) || KRB5TYPES_REQUIRE_GNUC(3,1,0) #define HEIMDAL_NORETURN_ATTRIBUTE __attribute__ ((__noreturn__)) #else #define HEIMDAL_NORETURN_ATTRIBUTE #endif #endif #ifndef HEIMDAL_UNUSED_ATTRIBUTE #if __has_extension(unused) || KRB5TYPES_REQUIRE_GNUC(3,1,0) #define HEIMDAL_UNUSED_ATTRIBUTE __attribute__ ((__unused__)) #else #define HEIMDAL_UNUSED_ATTRIBUTE #endif #endif #ifndef HEIMDAL_WARN_UNUSED_RESULT_ATTRIBUTE #if __has_extension(warn_unused_result) || KRB5TYPES_REQUIRE_GNUC(3,3,0) #define HEIMDAL_WARN_UNUSED_RESULT_ATTRIBUTE __attribute__ ((__warn_unused_result__)) #else #define HEIMDAL_WARN_UNUSED_RESULT_ATTRIBUTE #endif #endif #endif /* __krb5_types_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/krb5.h000066400000000000000000001013611505521762700216320ustar00rootroot00000000000000/* * Copyright (c) 1997 - 2007 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Portions Copyright (c) 2009 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef __KRB5_H__ #define __KRB5_H__ #include #include #include #include #include #include #include /* name confusion with MIT */ #ifndef KRB5KDC_ERR_KEY_EXP #define KRB5KDC_ERR_KEY_EXP KRB5KDC_ERR_KEY_EXPIRED #endif #ifdef _WIN32 #define KRB5_CALLCONV __stdcall #else #define KRB5_CALLCONV #endif /* simple constants */ #ifndef TRUE #define TRUE 1 #define FALSE 0 #endif typedef int krb5_boolean; typedef int32_t krb5_error_code; typedef int32_t krb5_kvno; typedef uint32_t krb5_flags; typedef void *krb5_pointer; typedef const void *krb5_const_pointer; struct krb5_crypto_data; typedef struct krb5_crypto_data *krb5_crypto; struct krb5_get_creds_opt_data; typedef struct krb5_get_creds_opt_data *krb5_get_creds_opt; struct krb5_digest_data; typedef struct krb5_digest_data *krb5_digest; struct krb5_ntlm_data; typedef struct krb5_ntlm_data *krb5_ntlm; struct krb5_pac_data; typedef struct krb5_pac_data *krb5_pac; typedef struct krb5_rd_req_in_ctx_data *krb5_rd_req_in_ctx; typedef struct krb5_rd_req_out_ctx_data *krb5_rd_req_out_ctx; typedef CKSUMTYPE krb5_cksumtype; typedef Checksum krb5_checksum; typedef ENCTYPE krb5_enctype; typedef struct krb5_get_init_creds_ctx *krb5_init_creds_context; typedef heim_octet_string krb5_data; /* PKINIT related forward declarations */ struct ContentInfo; struct krb5_pk_identity; struct krb5_pk_cert; /* krb5_enc_data is a mit compat structure */ typedef struct krb5_enc_data { krb5_enctype enctype; krb5_kvno kvno; krb5_data ciphertext; } krb5_enc_data; /* alternative names */ enum { ENCTYPE_NULL = KRB5_ENCTYPE_NULL, ENCTYPE_DES_CBC_CRC = KRB5_ENCTYPE_DES_CBC_CRC, ENCTYPE_DES_CBC_MD4 = KRB5_ENCTYPE_DES_CBC_MD4, ENCTYPE_DES_CBC_MD5 = KRB5_ENCTYPE_DES_CBC_MD5, ENCTYPE_DES3_CBC_MD5 = KRB5_ENCTYPE_DES3_CBC_MD5, ENCTYPE_OLD_DES3_CBC_SHA1 = KRB5_ENCTYPE_OLD_DES3_CBC_SHA1, ENCTYPE_SIGN_DSA_GENERATE = KRB5_ENCTYPE_SIGN_DSA_GENERATE, ENCTYPE_ENCRYPT_RSA_PRIV = KRB5_ENCTYPE_ENCRYPT_RSA_PRIV, ENCTYPE_ENCRYPT_RSA_PUB = KRB5_ENCTYPE_ENCRYPT_RSA_PUB, ENCTYPE_DES3_CBC_SHA1 = KRB5_ENCTYPE_DES3_CBC_SHA1, ENCTYPE_AES128_CTS_HMAC_SHA1_96 = KRB5_ENCTYPE_AES128_CTS_HMAC_SHA1_96, ENCTYPE_AES256_CTS_HMAC_SHA1_96 = KRB5_ENCTYPE_AES256_CTS_HMAC_SHA1_96, ENCTYPE_ARCFOUR_HMAC = KRB5_ENCTYPE_ARCFOUR_HMAC_MD5, ENCTYPE_ARCFOUR_HMAC_MD5 = KRB5_ENCTYPE_ARCFOUR_HMAC_MD5, ENCTYPE_ARCFOUR_HMAC_MD5_56 = KRB5_ENCTYPE_ARCFOUR_HMAC_MD5_56, ENCTYPE_ENCTYPE_PK_CROSS = KRB5_ENCTYPE_ENCTYPE_PK_CROSS, ENCTYPE_DES_CBC_NONE = KRB5_ENCTYPE_DES_CBC_NONE, ENCTYPE_DES3_CBC_NONE = KRB5_ENCTYPE_DES3_CBC_NONE, ENCTYPE_DES_CFB64_NONE = KRB5_ENCTYPE_DES_CFB64_NONE, ENCTYPE_DES_PCBC_NONE = KRB5_ENCTYPE_DES_PCBC_NONE, ETYPE_NULL = KRB5_ENCTYPE_NULL, ETYPE_DES_CBC_CRC = KRB5_ENCTYPE_DES_CBC_CRC, ETYPE_DES_CBC_MD4 = KRB5_ENCTYPE_DES_CBC_MD4, ETYPE_DES_CBC_MD5 = KRB5_ENCTYPE_DES_CBC_MD5, ETYPE_DES3_CBC_MD5 = KRB5_ENCTYPE_DES3_CBC_MD5, ETYPE_OLD_DES3_CBC_SHA1 = KRB5_ENCTYPE_OLD_DES3_CBC_SHA1, ETYPE_SIGN_DSA_GENERATE = KRB5_ENCTYPE_SIGN_DSA_GENERATE, ETYPE_ENCRYPT_RSA_PRIV = KRB5_ENCTYPE_ENCRYPT_RSA_PRIV, ETYPE_ENCRYPT_RSA_PUB = KRB5_ENCTYPE_ENCRYPT_RSA_PUB, ETYPE_DES3_CBC_SHA1 = KRB5_ENCTYPE_DES3_CBC_SHA1, ETYPE_AES128_CTS_HMAC_SHA1_96 = KRB5_ENCTYPE_AES128_CTS_HMAC_SHA1_96, ETYPE_AES256_CTS_HMAC_SHA1_96 = KRB5_ENCTYPE_AES256_CTS_HMAC_SHA1_96, ETYPE_AES128_CTS_HMAC_SHA256_128 = KRB5_ENCTYPE_AES128_CTS_HMAC_SHA256_128, ETYPE_AES256_CTS_HMAC_SHA384_192 = KRB5_ENCTYPE_AES256_CTS_HMAC_SHA384_192, ETYPE_ARCFOUR_HMAC_MD5 = KRB5_ENCTYPE_ARCFOUR_HMAC_MD5, ETYPE_ARCFOUR_HMAC_MD5_56 = KRB5_ENCTYPE_ARCFOUR_HMAC_MD5_56, ETYPE_ENCTYPE_PK_CROSS = KRB5_ENCTYPE_ENCTYPE_PK_CROSS, ETYPE_ARCFOUR_MD4 = KRB5_ENCTYPE_ARCFOUR_MD4, ETYPE_ARCFOUR_HMAC_OLD = KRB5_ENCTYPE_ARCFOUR_HMAC_OLD, ETYPE_ARCFOUR_HMAC_OLD_EXP = KRB5_ENCTYPE_ARCFOUR_HMAC_OLD_EXP, ETYPE_DES_CBC_NONE = KRB5_ENCTYPE_DES_CBC_NONE, ETYPE_DES3_CBC_NONE = KRB5_ENCTYPE_DES3_CBC_NONE, ETYPE_DES_CFB64_NONE = KRB5_ENCTYPE_DES_CFB64_NONE, ETYPE_DES_PCBC_NONE = KRB5_ENCTYPE_DES_PCBC_NONE, ETYPE_DIGEST_MD5_NONE = KRB5_ENCTYPE_DIGEST_MD5_NONE, ETYPE_CRAM_MD5_NONE = KRB5_ENCTYPE_CRAM_MD5_NONE }; /* PDU types */ typedef enum krb5_pdu { KRB5_PDU_ERROR = 0, KRB5_PDU_TICKET = 1, KRB5_PDU_AS_REQUEST = 2, KRB5_PDU_AS_REPLY = 3, KRB5_PDU_TGS_REQUEST = 4, KRB5_PDU_TGS_REPLY = 5, KRB5_PDU_AP_REQUEST = 6, KRB5_PDU_AP_REPLY = 7, KRB5_PDU_KRB_SAFE = 8, KRB5_PDU_KRB_PRIV = 9, KRB5_PDU_KRB_CRED = 10, KRB5_PDU_NONE = 11 /* See krb5_get_permitted_enctypes() */ } krb5_pdu; typedef PADATA_TYPE krb5_preauthtype; typedef enum krb5_key_usage { KRB5_KU_PA_ENC_TIMESTAMP = 1, /* AS-REQ PA-ENC-TIMESTAMP padata timestamp, encrypted with the client key (section 5.4.1) */ KRB5_KU_TICKET = 2, /* AS-REP Ticket and TGS-REP Ticket (includes tgs session key or application session key), encrypted with the service key (section 5.4.2) */ KRB5_KU_AS_REP_ENC_PART = 3, /* AS-REP encrypted part (includes tgs session key or application session key), encrypted with the client key (section 5.4.2) */ KRB5_KU_TGS_REQ_AUTH_DAT_SESSION = 4, /* TGS-REQ KDC-REQ-BODY AuthorizationData, encrypted with the tgs session key (section 5.4.1) */ KRB5_KU_TGS_REQ_AUTH_DAT_SUBKEY = 5, /* TGS-REQ KDC-REQ-BODY AuthorizationData, encrypted with the tgs authenticator subkey (section 5.4.1) */ KRB5_KU_TGS_REQ_AUTH_CKSUM = 6, /* TGS-REQ PA-TGS-REQ padata AP-REQ Authenticator cksum, keyed with the tgs session key (sections 5.3.2, 5.4.1) */ KRB5_KU_TGS_REQ_AUTH = 7, /* TGS-REQ PA-TGS-REQ padata AP-REQ Authenticator (includes tgs authenticator subkey), encrypted with the tgs session key (section 5.3.2) */ KRB5_KU_TGS_REP_ENC_PART_SESSION = 8, /* TGS-REP encrypted part (includes application session key), encrypted with the tgs session key (section 5.4.2) */ KRB5_KU_TGS_REP_ENC_PART_SUB_KEY = 9, /* TGS-REP encrypted part (includes application session key), encrypted with the tgs authenticator subkey (section 5.4.2) */ KRB5_KU_AP_REQ_AUTH_CKSUM = 10, /* AP-REQ Authenticator cksum, keyed with the application session key (section 5.3.2) */ KRB5_KU_AP_REQ_AUTH = 11, /* AP-REQ Authenticator (includes application authenticator subkey), encrypted with the application session key (section 5.3.2) */ KRB5_KU_AP_REQ_ENC_PART = 12, /* AP-REP encrypted part (includes application session subkey), encrypted with the application session key (section 5.5.2) */ KRB5_KU_KRB_PRIV = 13, /* KRB-PRIV encrypted part, encrypted with a key chosen by the application (section 5.7.1) */ KRB5_KU_KRB_CRED = 14, /* KRB-CRED encrypted part, encrypted with a key chosen by the application (section 5.8.1) */ KRB5_KU_KRB_SAFE_CKSUM = 15, /* KRB-SAFE cksum, keyed with a key chosen by the application (section 5.6.1) */ KRB5_KU_OTHER_ENCRYPTED = 16, /* Data which is defined in some specification outside of Kerberos to be encrypted using an RFC1510 encryption type. */ KRB5_KU_OTHER_CKSUM = 17, /* Data which is defined in some specification outside of Kerberos to be checksummed using an RFC1510 checksum type. */ KRB5_KU_KRB_ERROR = 18, /* Krb-error checksum */ KRB5_KU_AD_KDC_ISSUED = 19, /* AD-KDCIssued checksum */ KRB5_KU_MANDATORY_TICKET_EXTENSION = 20, /* Checksum for Mandatory Ticket Extensions */ KRB5_KU_AUTH_DATA_TICKET_EXTENSION = 21, /* Checksum in Authorization Data in Ticket Extensions */ KRB5_KU_USAGE_SEAL = 22, /* seal in GSSAPI krb5 mechanism */ KRB5_KU_USAGE_SIGN = 23, /* sign in GSSAPI krb5 mechanism */ KRB5_KU_USAGE_SEQ = 24, /* SEQ in GSSAPI krb5 mechanism */ KRB5_KU_USAGE_ACCEPTOR_SEAL = 22, /* acceptor sign in GSSAPI CFX krb5 mechanism */ KRB5_KU_USAGE_ACCEPTOR_SIGN = 23, /* acceptor seal in GSSAPI CFX krb5 mechanism */ KRB5_KU_USAGE_INITIATOR_SEAL = 24, /* initiator sign in GSSAPI CFX krb5 mechanism */ KRB5_KU_USAGE_INITIATOR_SIGN = 25, /* initiator seal in GSSAPI CFX krb5 mechanism */ KRB5_KU_PA_SERVER_REFERRAL_DATA = 22, /* encrypted server referral data */ KRB5_KU_SAM_CHECKSUM = 25, /* Checksum for the SAM-CHECKSUM field */ KRB5_KU_SAM_ENC_TRACK_ID = 26, /* Encryption of the SAM-TRACK-ID field */ KRB5_KU_PA_SERVER_REFERRAL = 26, /* Keyusage for the server referral in a TGS req */ KRB5_KU_SAM_ENC_NONCE_SAD = 27, /* Encryption of the SAM-NONCE-OR-SAD field */ KRB5_KU_PA_PKINIT_KX = 44, /* Encryption type of the kdc session contribution in pk-init */ KRB5_KU_AS_REQ = 56, /* Checksum of over the AS-REQ send by the KDC in PA-REQ-ENC-PA-REP */ KRB5_KU_FAST_REQ_CHKSUM = 50, /* FAST armor checksum */ KRB5_KU_FAST_ENC = 51, /* FAST armor encryption */ KRB5_KU_FAST_REP = 52, /* FAST armor reply */ KRB5_KU_FAST_FINISHED = 53, /* FAST finished checksum */ KRB5_KU_ENC_CHALLENGE_CLIENT = 54, /* fast challenge from client */ KRB5_KU_ENC_CHALLENGE_KDC = 55, /* fast challenge from kdc */ KRB5_KU_DIGEST_ENCRYPT = -18, /* Encryption key usage used in the digest encryption field */ KRB5_KU_DIGEST_OPAQUE = -19, /* Checksum key usage used in the digest opaque field */ KRB5_KU_KRB5SIGNEDPATH = -21, /* Checksum key usage on KRB5SignedPath */ KRB5_KU_CANONICALIZED_NAMES = -23, /* Checksum key usage on PA-CANONICALIZED */ KRB5_KU_H5L_COOKIE = -25 /* encrypted foo */ } krb5_key_usage; typedef krb5_key_usage krb5_keyusage; typedef enum krb5_salttype { KRB5_PW_SALT = KRB5_PADATA_PW_SALT, KRB5_AFS3_SALT = KRB5_PADATA_AFS3_SALT }krb5_salttype; typedef struct krb5_salt { krb5_salttype salttype; krb5_data saltvalue; } krb5_salt; typedef ETYPE_INFO krb5_preauthinfo; typedef struct { krb5_preauthtype type; krb5_preauthinfo info; /* list of preauthinfo for this type */ } krb5_preauthdata_entry; typedef struct krb5_preauthdata { unsigned len; krb5_preauthdata_entry *val; }krb5_preauthdata; typedef enum krb5_address_type { KRB5_ADDRESS_INET = 2, KRB5_ADDRESS_NETBIOS = 20, KRB5_ADDRESS_INET6 = 24, KRB5_ADDRESS_ADDRPORT = 256, KRB5_ADDRESS_IPPORT = 257 } krb5_address_type; enum { AP_OPTS_USE_SESSION_KEY = 1, AP_OPTS_MUTUAL_REQUIRED = 2, AP_OPTS_USE_SUBKEY = 4 /* library internal */ }; typedef HostAddress krb5_address; typedef HostAddresses krb5_addresses; typedef krb5_enctype krb5_keytype; enum krb5_keytype_old { KEYTYPE_NULL = ETYPE_NULL, KEYTYPE_DES = ETYPE_DES_CBC_CRC, KEYTYPE_DES3 = ETYPE_OLD_DES3_CBC_SHA1, KEYTYPE_AES128 = ETYPE_AES128_CTS_HMAC_SHA1_96, KEYTYPE_AES256 = ETYPE_AES256_CTS_HMAC_SHA1_96, KEYTYPE_ARCFOUR = ETYPE_ARCFOUR_HMAC_MD5, KEYTYPE_ARCFOUR_56 = ETYPE_ARCFOUR_HMAC_MD5_56 }; typedef EncryptionKey krb5_keyblock; typedef AP_REQ krb5_ap_req; struct krb5_cc_ops; #ifdef _WIN32 #define KRB5_USE_PATH_TOKENS 1 #endif #ifdef KRB5_USE_PATH_TOKENS #define KRB5_DEFAULT_CCFILE_ROOT "%{TEMP}/krb5cc_" #else #define KRB5_DEFAULT_CCFILE_ROOT "/tmp/krb5cc_" #endif #define KRB5_DEFAULT_CCROOT "FILE:" KRB5_DEFAULT_CCFILE_ROOT #define KRB5_ACCEPT_NULL_ADDRESSES(C) \ krb5_config_get_bool_default((C), NULL, TRUE, \ "libdefaults", "accept_null_addresses", \ NULL) typedef void *krb5_cc_cursor; typedef struct krb5_cccol_cursor_data *krb5_cccol_cursor; typedef struct krb5_ccache_data { const struct krb5_cc_ops *ops; krb5_data data; int initialized; /* if non-zero: krb5_cc_initialize() called, now empty */ }krb5_ccache_data; typedef struct krb5_ccache_data *krb5_ccache; typedef struct krb5_context_data *krb5_context; typedef Realm krb5_realm; typedef const char *krb5_const_realm; /* stupid language */ #define krb5_realm_length(r) strlen(r) #define krb5_realm_data(r) (r) typedef Principal krb5_principal_data; typedef struct Principal *krb5_principal; typedef const struct Principal *krb5_const_principal; typedef struct Principals *krb5_principals; typedef time_t krb5_deltat; typedef time_t krb5_timestamp; typedef struct krb5_times { krb5_timestamp authtime; krb5_timestamp starttime; krb5_timestamp endtime; krb5_timestamp renew_till; } krb5_times; typedef union { TicketFlags b; krb5_flags i; } krb5_ticket_flags; /* options for krb5_get_in_tkt() */ #define KDC_OPT_FORWARDABLE (1 << 1) #define KDC_OPT_FORWARDED (1 << 2) #define KDC_OPT_PROXIABLE (1 << 3) #define KDC_OPT_PROXY (1 << 4) #define KDC_OPT_ALLOW_POSTDATE (1 << 5) #define KDC_OPT_POSTDATED (1 << 6) #define KDC_OPT_RENEWABLE (1 << 8) #define KDC_OPT_REQUEST_ANONYMOUS (1 << 14) #define KDC_OPT_DISABLE_TRANSITED_CHECK (1 << 26) #define KDC_OPT_RENEWABLE_OK (1 << 27) #define KDC_OPT_ENC_TKT_IN_SKEY (1 << 28) #define KDC_OPT_RENEW (1 << 30) #define KDC_OPT_VALIDATE (1 << 31) typedef union { KDCOptions b; krb5_flags i; } krb5_kdc_flags; /* flags for krb5_verify_ap_req */ #define KRB5_VERIFY_AP_REQ_IGNORE_INVALID (1 << 0) #define KRB5_GC_CACHED (1U << 0) #define KRB5_GC_USER_USER (1U << 1) #define KRB5_GC_EXPIRED_OK (1U << 2) #define KRB5_GC_NO_STORE (1U << 3) #define KRB5_GC_FORWARDABLE (1U << 4) #define KRB5_GC_NO_TRANSIT_CHECK (1U << 5) #define KRB5_GC_CONSTRAINED_DELEGATION (1U << 6) #define KRB5_GC_CANONICALIZE (1U << 7) #define KRB5_GC_ANONYMOUS (1U << 8) /* constants for compare_creds (and cc_retrieve_cred) */ #define KRB5_TC_DONT_MATCH_REALM (1U << 31) #define KRB5_TC_MATCH_KEYTYPE (1U << 30) #define KRB5_TC_MATCH_KTYPE KRB5_TC_MATCH_KEYTYPE /* MIT name */ #define KRB5_TC_MATCH_SRV_NAMEONLY (1 << 29) #define KRB5_TC_MATCH_FLAGS_EXACT (1 << 28) #define KRB5_TC_MATCH_FLAGS (1 << 27) #define KRB5_TC_MATCH_TIMES_EXACT (1 << 26) #define KRB5_TC_MATCH_TIMES (1 << 25) #define KRB5_TC_MATCH_AUTHDATA (1 << 24) #define KRB5_TC_MATCH_2ND_TKT (1 << 23) #define KRB5_TC_MATCH_IS_SKEY (1 << 22) /* constants for get_flags and set_flags */ #define KRB5_TC_OPENCLOSE 0x00000001 #define KRB5_TC_NOTICKET 0x00000002 typedef AuthorizationData krb5_authdata; typedef KRB_ERROR krb5_error; typedef struct krb5_creds { krb5_principal client; krb5_principal server; krb5_keyblock session; krb5_times times; krb5_data ticket; krb5_data second_ticket; krb5_authdata authdata; krb5_addresses addresses; krb5_ticket_flags flags; } krb5_creds; typedef struct krb5_cc_cache_cursor_data *krb5_cc_cache_cursor; #define KRB5_CC_OPS_VERSION 3 typedef struct krb5_cc_ops { int version; const char *prefix; const char* (KRB5_CALLCONV * get_name)(krb5_context, krb5_ccache); krb5_error_code (KRB5_CALLCONV * resolve)(krb5_context, krb5_ccache *, const char *); krb5_error_code (KRB5_CALLCONV * gen_new)(krb5_context, krb5_ccache *); krb5_error_code (KRB5_CALLCONV * init)(krb5_context, krb5_ccache, krb5_principal); krb5_error_code (KRB5_CALLCONV * destroy)(krb5_context, krb5_ccache); krb5_error_code (KRB5_CALLCONV * close)(krb5_context, krb5_ccache); krb5_error_code (KRB5_CALLCONV * store)(krb5_context, krb5_ccache, krb5_creds*); krb5_error_code (KRB5_CALLCONV * retrieve)(krb5_context, krb5_ccache, krb5_flags, const krb5_creds*, krb5_creds *); krb5_error_code (KRB5_CALLCONV * get_princ)(krb5_context, krb5_ccache, krb5_principal*); krb5_error_code (KRB5_CALLCONV * get_first)(krb5_context, krb5_ccache, krb5_cc_cursor *); krb5_error_code (KRB5_CALLCONV * get_next)(krb5_context, krb5_ccache, krb5_cc_cursor*, krb5_creds*); krb5_error_code (KRB5_CALLCONV * end_get)(krb5_context, krb5_ccache, krb5_cc_cursor*); krb5_error_code (KRB5_CALLCONV * remove_cred)(krb5_context, krb5_ccache, krb5_flags, krb5_creds*); krb5_error_code (KRB5_CALLCONV * set_flags)(krb5_context, krb5_ccache, krb5_flags); int (KRB5_CALLCONV * get_version)(krb5_context, krb5_ccache); krb5_error_code (KRB5_CALLCONV * get_cache_first)(krb5_context, krb5_cc_cursor *); krb5_error_code (KRB5_CALLCONV * get_cache_next)(krb5_context, krb5_cc_cursor, krb5_ccache *); krb5_error_code (KRB5_CALLCONV * end_cache_get)(krb5_context, krb5_cc_cursor); krb5_error_code (KRB5_CALLCONV * move)(krb5_context, krb5_ccache, krb5_ccache); krb5_error_code (KRB5_CALLCONV * get_default_name)(krb5_context, char **); krb5_error_code (KRB5_CALLCONV * set_default)(krb5_context, krb5_ccache); krb5_error_code (KRB5_CALLCONV * lastchange)(krb5_context, krb5_ccache, krb5_timestamp *); krb5_error_code (KRB5_CALLCONV * set_kdc_offset)(krb5_context, krb5_ccache, krb5_deltat); krb5_error_code (KRB5_CALLCONV * get_kdc_offset)(krb5_context, krb5_ccache, krb5_deltat *); } krb5_cc_ops; struct krb5_log_facility; struct krb5_config_binding { enum { krb5_config_string, krb5_config_list } type; char *name; struct krb5_config_binding *next; union { char *string; struct krb5_config_binding *list; void *generic; } u; }; typedef struct krb5_config_binding krb5_config_binding; typedef krb5_config_binding krb5_config_section; typedef struct krb5_ticket { EncTicketPart ticket; krb5_principal client; krb5_principal server; } krb5_ticket; typedef Authenticator krb5_authenticator_data; typedef krb5_authenticator_data *krb5_authenticator; struct krb5_rcache_data; typedef struct krb5_rcache_data *krb5_rcache; typedef Authenticator krb5_donot_replay; #define KRB5_STORAGE_HOST_BYTEORDER 0x01 /* old */ #define KRB5_STORAGE_PRINCIPAL_WRONG_NUM_COMPONENTS 0x02 #define KRB5_STORAGE_PRINCIPAL_NO_NAME_TYPE 0x04 #define KRB5_STORAGE_KEYBLOCK_KEYTYPE_TWICE 0x08 #define KRB5_STORAGE_BYTEORDER_MASK 0x60 #define KRB5_STORAGE_BYTEORDER_BE 0x00 /* default */ #define KRB5_STORAGE_BYTEORDER_LE 0x20 #define KRB5_STORAGE_BYTEORDER_HOST 0x40 #define KRB5_STORAGE_CREDS_FLAGS_WRONG_BITORDER 0x80 struct krb5_storage_data; typedef struct krb5_storage_data krb5_storage; typedef struct krb5_keytab_entry { krb5_principal principal; krb5_kvno vno; krb5_keyblock keyblock; uint32_t timestamp; uint32_t flags; krb5_principals aliases; } krb5_keytab_entry; typedef struct krb5_kt_cursor { int fd; krb5_storage *sp; void *data; } krb5_kt_cursor; struct krb5_keytab_data; typedef struct krb5_keytab_data *krb5_keytab; #define KRB5_KT_PREFIX_MAX_LEN 30 struct krb5_keytab_data { const char *prefix; krb5_error_code (KRB5_CALLCONV * resolve)(krb5_context, const char*, krb5_keytab); krb5_error_code (KRB5_CALLCONV * get_name)(krb5_context, krb5_keytab, char*, size_t); krb5_error_code (KRB5_CALLCONV * close)(krb5_context, krb5_keytab); krb5_error_code (KRB5_CALLCONV * destroy)(krb5_context, krb5_keytab); krb5_error_code (KRB5_CALLCONV * get)(krb5_context, krb5_keytab, krb5_const_principal, krb5_kvno, krb5_enctype, krb5_keytab_entry*); krb5_error_code (KRB5_CALLCONV * start_seq_get)(krb5_context, krb5_keytab, krb5_kt_cursor*); krb5_error_code (KRB5_CALLCONV * next_entry)(krb5_context, krb5_keytab, krb5_keytab_entry*, krb5_kt_cursor*); krb5_error_code (KRB5_CALLCONV * end_seq_get)(krb5_context, krb5_keytab, krb5_kt_cursor*); krb5_error_code (KRB5_CALLCONV * add)(krb5_context, krb5_keytab, krb5_keytab_entry*); krb5_error_code (KRB5_CALLCONV * remove)(krb5_context, krb5_keytab, krb5_keytab_entry*); void *data; int32_t version; }; typedef struct krb5_keytab_data krb5_kt_ops; struct krb5_keytab_key_proc_args { krb5_keytab keytab; krb5_principal principal; }; typedef struct krb5_keytab_key_proc_args krb5_keytab_key_proc_args; typedef struct krb5_replay_data { krb5_timestamp timestamp; int32_t usec; uint32_t seq; } krb5_replay_data; /* flags for krb5_auth_con_setflags */ enum { KRB5_AUTH_CONTEXT_DO_TIME = 1, KRB5_AUTH_CONTEXT_RET_TIME = 2, KRB5_AUTH_CONTEXT_DO_SEQUENCE = 4, KRB5_AUTH_CONTEXT_RET_SEQUENCE = 8, KRB5_AUTH_CONTEXT_PERMIT_ALL = 16, KRB5_AUTH_CONTEXT_USE_SUBKEY = 32, KRB5_AUTH_CONTEXT_CLEAR_FORWARDED_CRED = 64 }; /* flags for krb5_auth_con_genaddrs */ enum { KRB5_AUTH_CONTEXT_GENERATE_LOCAL_ADDR = 1, KRB5_AUTH_CONTEXT_GENERATE_LOCAL_FULL_ADDR = 3, KRB5_AUTH_CONTEXT_GENERATE_REMOTE_ADDR = 4, KRB5_AUTH_CONTEXT_GENERATE_REMOTE_FULL_ADDR = 12 }; typedef struct krb5_auth_context_data { unsigned int flags; krb5_address *local_address; krb5_address *remote_address; int16_t local_port; int16_t remote_port; krb5_keyblock *keyblock; krb5_keyblock *local_subkey; krb5_keyblock *remote_subkey; uint32_t local_seqnumber; uint32_t remote_seqnumber; krb5_authenticator authenticator; krb5_pointer i_vector; krb5_rcache rcache; krb5_keytype keytype; /* ¿requested key type ? */ krb5_cksumtype cksumtype; /* ¡requested checksum type! */ AuthorizationData *auth_data; }krb5_auth_context_data, *krb5_auth_context; typedef struct { KDC_REP kdc_rep; EncKDCRepPart enc_part; KRB_ERROR error; } krb5_kdc_rep; extern const char *heimdal_version, *heimdal_long_version; typedef void (KRB5_CALLCONV * krb5_log_log_func_t)(const char*, const char*, void*); typedef void (KRB5_CALLCONV * krb5_log_close_func_t)(void*); typedef struct krb5_log_facility { char *program; int len; struct facility *val; } krb5_log_facility; typedef EncAPRepPart krb5_ap_rep_enc_part; #define KRB5_RECVAUTH_IGNORE_VERSION 1 #define KRB5_SENDAUTH_VERSION "KRB5_SENDAUTH_V1.0" #define KRB5_TGS_NAME_SIZE (6) #define KRB5_TGS_NAME ("krbtgt") #define KRB5_WELLKNOWN_NAME ("WELLKNOWN") #define KRB5_ANON_NAME ("ANONYMOUS") #define KRB5_ANON_REALM ("WELLKNOWN:ANONYMOUS") #define KRB5_WELLKNOWN_ORG_H5L_REALM ("WELLKNOWN:ORG.H5L") #define KRB5_DIGEST_NAME ("digest") #define KRB5_PKU2U_REALM_NAME ("WELLKNOWN:PKU2U") #define KRB5_LKDC_REALM_NAME ("WELLKNOWN:COM.APPLE.LKDC") #define KRB5_GSS_HOSTBASED_SERVICE_NAME ("WELLKNOWN:ORG.H5L.HOSTBASED-SERVICE") #define KRB5_GSS_REFERALS_REALM_NAME ("WELLKNOWN:ORG.H5L.REFERALS-REALM") typedef enum { KRB5_PROMPT_TYPE_PASSWORD = 0x1, KRB5_PROMPT_TYPE_NEW_PASSWORD = 0x2, KRB5_PROMPT_TYPE_NEW_PASSWORD_AGAIN = 0x3, KRB5_PROMPT_TYPE_PREAUTH = 0x4, KRB5_PROMPT_TYPE_INFO = 0x5 } krb5_prompt_type; typedef struct _krb5_prompt { const char *prompt; int hidden; krb5_data *reply; krb5_prompt_type type; } krb5_prompt; typedef int (KRB5_CALLCONV * krb5_prompter_fct)(krb5_context /*context*/, void * /*data*/, const char * /*name*/, const char * /*banner*/, int /*num_prompts*/, krb5_prompt /*prompts*/[]); typedef krb5_error_code (KRB5_CALLCONV * krb5_key_proc)(krb5_context /*context*/, krb5_enctype /*type*/, krb5_salt /*salt*/, krb5_const_pointer /*keyseed*/, krb5_keyblock ** /*key*/); typedef krb5_error_code (KRB5_CALLCONV * krb5_decrypt_proc)(krb5_context /*context*/, krb5_keyblock * /*key*/, krb5_key_usage /*usage*/, krb5_const_pointer /*decrypt_arg*/, krb5_kdc_rep * /*dec_rep*/); typedef krb5_error_code (KRB5_CALLCONV * krb5_s2k_proc)(krb5_context /*context*/, krb5_enctype /*type*/, krb5_const_pointer /*keyseed*/, krb5_salt /*salt*/, krb5_data * /*s2kparms*/, krb5_keyblock ** /*key*/); struct _krb5_get_init_creds_opt_private; struct _krb5_get_init_creds_opt { krb5_flags flags; krb5_deltat tkt_life; krb5_deltat renew_life; int forwardable; int proxiable; int anonymous; int change_password_prompt; krb5_enctype *etype_list; int etype_list_length; krb5_addresses *address_list; /* XXX the next three should not be used, as they may be removed later */ krb5_preauthtype *preauth_list; int preauth_list_length; krb5_data *salt; struct _krb5_get_init_creds_opt_private *opt_private; }; typedef struct _krb5_get_init_creds_opt krb5_get_init_creds_opt; #define KRB5_GET_INIT_CREDS_OPT_TKT_LIFE 0x0001 #define KRB5_GET_INIT_CREDS_OPT_RENEW_LIFE 0x0002 #define KRB5_GET_INIT_CREDS_OPT_FORWARDABLE 0x0004 #define KRB5_GET_INIT_CREDS_OPT_PROXIABLE 0x0008 #define KRB5_GET_INIT_CREDS_OPT_ETYPE_LIST 0x0010 #define KRB5_GET_INIT_CREDS_OPT_ADDRESS_LIST 0x0020 #define KRB5_GET_INIT_CREDS_OPT_PREAUTH_LIST 0x0040 #define KRB5_GET_INIT_CREDS_OPT_SALT 0x0080 /* no supported */ #define KRB5_GET_INIT_CREDS_OPT_ANONYMOUS 0x0100 #define KRB5_GET_INIT_CREDS_OPT_DISABLE_TRANSITED_CHECK 0x0200 #define KRB5_GET_INIT_CREDS_OPT_CHANGE_PASSWORD_PROMPT 0x0400 /* krb5_init_creds_step flags argument */ #define KRB5_INIT_CREDS_STEP_FLAG_CONTINUE 0x0001 typedef struct _krb5_verify_init_creds_opt { krb5_flags flags; int ap_req_nofail; } krb5_verify_init_creds_opt; #define KRB5_VERIFY_INIT_CREDS_OPT_AP_REQ_NOFAIL 0x0001 typedef struct krb5_verify_opt { unsigned int flags; krb5_ccache ccache; krb5_keytab keytab; krb5_boolean secure; const char *service; } krb5_verify_opt; #define KRB5_VERIFY_LREALMS 1 #define KRB5_VERIFY_NO_ADDRESSES 2 #define KRB5_KPASSWD_VERS_CHANGEPW 1 #define KRB5_KPASSWD_VERS_SETPW 0xff80 #define KRB5_KPASSWD_SUCCESS 0 #define KRB5_KPASSWD_MALFORMED 1 #define KRB5_KPASSWD_HARDERROR 2 #define KRB5_KPASSWD_AUTHERROR 3 #define KRB5_KPASSWD_SOFTERROR 4 #define KRB5_KPASSWD_ACCESSDENIED 5 #define KRB5_KPASSWD_BAD_VERSION 6 #define KRB5_KPASSWD_INITIAL_FLAG_NEEDED 7 #define KPASSWD_PORT 464 /* types for the new krbhst interface */ struct krb5_krbhst_data; typedef struct krb5_krbhst_data *krb5_krbhst_handle; #define KRB5_KRBHST_KDC 1 #define KRB5_KRBHST_ADMIN 2 #define KRB5_KRBHST_CHANGEPW 3 #define KRB5_KRBHST_KRB524 4 #define KRB5_KRBHST_KCA 5 typedef struct krb5_krbhst_info { enum { KRB5_KRBHST_UDP, KRB5_KRBHST_TCP, KRB5_KRBHST_HTTP } proto; unsigned short port; unsigned short def_port; struct addrinfo *ai; struct krb5_krbhst_info *next; char hostname[1]; /* has to come last */ } krb5_krbhst_info; /* flags for krb5_krbhst_init_flags (and krb5_send_to_kdc_flags) */ enum { KRB5_KRBHST_FLAGS_MASTER = 1, KRB5_KRBHST_FLAGS_LARGE_MSG = 2 }; typedef krb5_error_code (*krb5_sendto_prexmit)(krb5_context, int, void *, int, krb5_data *); typedef krb5_error_code (KRB5_CALLCONV * krb5_send_to_kdc_func)(krb5_context, void *, krb5_krbhst_info *, time_t, const krb5_data *, krb5_data *); /** flags for krb5_parse_name_flags */ enum { KRB5_PRINCIPAL_PARSE_NO_REALM = 1, /**< Require that there are no realm */ KRB5_PRINCIPAL_PARSE_REQUIRE_REALM = 2, /**< Require a realm present */ KRB5_PRINCIPAL_PARSE_ENTERPRISE = 4, /**< Parse as a NT-ENTERPRISE name */ KRB5_PRINCIPAL_PARSE_IGNORE_REALM = 8, /**< Ignore realm if present */ KRB5_PRINCIPAL_PARSE_NO_DEF_REALM = 16 /**< Don't default the realm */ }; /** flags for krb5_unparse_name_flags */ enum { KRB5_PRINCIPAL_UNPARSE_SHORT = 1, /**< No realm if it is the default realm */ KRB5_PRINCIPAL_UNPARSE_NO_REALM = 2, /**< No realm */ KRB5_PRINCIPAL_UNPARSE_DISPLAY = 4 /**< No quoting */ }; typedef struct krb5_sendto_ctx_data *krb5_sendto_ctx; #define KRB5_SENDTO_DONE 0 #define KRB5_SENDTO_RESET 1 #define KRB5_SENDTO_CONTINUE 2 #define KRB5_SENDTO_TIMEOUT 3 #define KRB5_SENDTO_INITIAL 4 #define KRB5_SENDTO_FILTER 5 #define KRB5_SENDTO_FAILED 6 #define KRB5_SENDTO_KRBHST 7 typedef krb5_error_code (KRB5_CALLCONV * krb5_sendto_ctx_func)(krb5_context, krb5_sendto_ctx, void *, const krb5_data *, int *); struct krb5_plugin; enum krb5_plugin_type { PLUGIN_TYPE_DATA = 1, PLUGIN_TYPE_FUNC }; #define KRB5_PLUGIN_INVOKE_ALL 1 struct credentials; /* this is to keep the compiler happy */ struct getargs; struct sockaddr; /** * Semi private, not stable yet */ typedef struct krb5_crypto_iov { unsigned int flags; /* ignored */ #define KRB5_CRYPTO_TYPE_EMPTY 0 /* OUT krb5_crypto_length(KRB5_CRYPTO_TYPE_HEADER) */ #define KRB5_CRYPTO_TYPE_HEADER 1 /* IN and OUT */ #define KRB5_CRYPTO_TYPE_DATA 2 /* IN */ #define KRB5_CRYPTO_TYPE_SIGN_ONLY 3 /* (only for encryption) OUT krb5_crypto_length(KRB5_CRYPTO_TYPE_TRAILER) */ #define KRB5_CRYPTO_TYPE_PADDING 4 /* OUT krb5_crypto_length(KRB5_CRYPTO_TYPE_TRAILER) */ #define KRB5_CRYPTO_TYPE_TRAILER 5 /* OUT krb5_crypto_length(KRB5_CRYPTO_TYPE_CHECKSUM) */ #define KRB5_CRYPTO_TYPE_CHECKSUM 6 krb5_data data; } krb5_crypto_iov; /* Glue for MIT */ typedef struct { int32_t lr_type; krb5_timestamp value; } krb5_last_req_entry; typedef krb5_error_code (KRB5_CALLCONV * krb5_gic_process_last_req)(krb5_context, krb5_last_req_entry **, void *); typedef struct { krb5_enctype ks_enctype; krb5int32 ks_salttype; }krb5_key_salt_tuple; /* * Name canonicalization rule options */ typedef enum krb5_name_canon_rule_options { KRB5_NCRO_GC_ONLY = 1 << 0, KRB5_NCRO_USE_REFERRALS = 1 << 1, KRB5_NCRO_NO_REFERRALS = 1 << 2, KRB5_NCRO_USE_FAST = 1 << 3, KRB5_NCRO_USE_DNSSEC = 1 << 4, KRB5_NCRO_LOOKUP_REALM = 1 << 5 } krb5_name_canon_rule_options; typedef struct krb5_name_canon_rule_data *krb5_name_canon_rule; typedef const struct krb5_name_canon_rule_data *krb5_const_name_canon_rule; typedef struct krb5_name_canon_iterator_data *krb5_name_canon_iterator; /* * krb5_get_init_creds_opt_set_pkinit flags */ #define KRB5_GIC_OPT_PKINIT_USE_ENCKEY 2 /* use RSA, not DH */ #define KRB5_GIC_OPT_PKINIT_ANONYMOUS 4 /* anonymous PKINIT */ #define KRB5_GIC_OPT_PKINIT_BTMM 8 /* reserved by Apple */ #define KRB5_GIC_OPT_PKINIT_NO_KDC_ANCHOR 16 /* do not authenticate KDC */ /* * _krb5_principal_is_anonymous() flags */ #define KRB5_ANON_MATCH_AUTHENTICATED 1 /* authenticated with anon flag */ #define KRB5_ANON_MATCH_UNAUTHENTICATED 2 /* anonymous PKINIT */ #define KRB5_ANON_MATCH_ANY ( KRB5_ANON_MATCH_AUTHENTICATED | KRB5_ANON_MATCH_UNAUTHENTICATED ) /* * */ struct hx509_certs_data; #include /* variables */ extern KRB5_LIB_VARIABLE const char *krb5_config_file; extern KRB5_LIB_VARIABLE const char *krb5_defkeyname; extern KRB5_LIB_VARIABLE const krb5_cc_ops krb5_acc_ops; extern KRB5_LIB_VARIABLE const krb5_cc_ops krb5_dcc_ops; extern KRB5_LIB_VARIABLE const krb5_cc_ops krb5_fcc_ops; extern KRB5_LIB_VARIABLE const krb5_cc_ops krb5_mcc_ops; extern KRB5_LIB_VARIABLE const krb5_cc_ops krb5_kcm_ops; extern KRB5_LIB_VARIABLE const krb5_cc_ops krb5_akcm_ops; extern KRB5_LIB_VARIABLE const krb5_cc_ops krb5_scc_ops; extern KRB5_LIB_VARIABLE const krb5_kt_ops krb5_fkt_ops; extern KRB5_LIB_VARIABLE const krb5_kt_ops krb5_wrfkt_ops; extern KRB5_LIB_VARIABLE const krb5_kt_ops krb5_javakt_ops; extern KRB5_LIB_VARIABLE const krb5_kt_ops krb5_mkt_ops; extern KRB5_LIB_VARIABLE const krb5_kt_ops krb5_akf_ops; extern KRB5_LIB_VARIABLE const krb5_kt_ops krb5_any_ops; extern KRB5_LIB_VARIABLE const char *krb5_cc_type_api; extern KRB5_LIB_VARIABLE const char *krb5_cc_type_file; extern KRB5_LIB_VARIABLE const char *krb5_cc_type_memory; extern KRB5_LIB_VARIABLE const char *krb5_cc_type_kcm; extern KRB5_LIB_VARIABLE const char *krb5_cc_type_scc; extern KRB5_LIB_VARIABLE const char *krb5_cc_type_dcc; #endif /* __KRB5_H__ */ pykrb5-0.8.0/build_helpers/heimdal/include/krb5/000077500000000000000000000000001505521762700214575ustar00rootroot00000000000000pykrb5-0.8.0/build_helpers/heimdal/include/krb5/an2ln_plugin.h000066400000000000000000000074401505521762700242250ustar00rootroot00000000000000/* * Copyright (c) 2006 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef HEIMDAL_KRB5_AN2LN_PLUGIN_H #define HEIMDAL_KRB5_AN2LN_PLUGIN_H 1 #define KRB5_PLUGIN_AN2LN "an2ln" #define KRB5_PLUGIN_AN2LN_VERSION_0 0 typedef krb5_error_code (KRB5_LIB_CALL *set_result_f)(void *, const char *); /** @struct krb5plugin_an2ln_ftable_desc * * @brief Description of the krb5_aname_to_lname(3) plugin facility. * * The krb5_aname_to_lname(3) function is pluggable. The plugin is * named KRB5_PLUGIN_AN2LN ("an2ln"), with a single minor version, * KRB5_PLUGIN_AN2LN_VERSION_0 (0). * * The plugin for krb5_aname_to_lname(3) consists of a data symbol * referencing a structure of type krb5plugin_an2ln_ftable, with four * fields: * * @param init Plugin initialization function (see krb5-plugin(7)) * * @param minor_version The plugin minor version number (0) * * @param fini Plugin finalization function * * @param an2ln Plugin aname_to_lname function * * The an2ln field is the plugin entry point that performs the * traditional aname_to_lname operation however the plugin desires. It * is invoked in no particular order relative to other an2ln plugins, * but it has a 'rule' argument that indicates which plugin is intended * to act on the rule. The plugin an2ln function must return * KRB5_PLUGIN_NO_HANDLE if the rule is not applicable to it. * * The plugin an2ln function has the following arguments, in this order: * * -# plug_ctx, the context value output by the plugin's init function * -# context, a krb5_context * -# rule, the aname_to_lname rule being evaluated (from krb5.conf(5)) * -# aname, the krb5_principal to be mapped to an lname * -# set_res_f, a function the plugin must call to set its result * -# set_res_ctx, the first argument to set_res_f (the second is the result lname string) * * @ingroup krb5_support */ typedef struct krb5plugin_an2ln_ftable_desc { int minor_version; krb5_error_code (KRB5_LIB_CALL *init)(krb5_context, void **); void (KRB5_LIB_CALL *fini)(void *); krb5_error_code (KRB5_LIB_CALL *an2ln)(void *, krb5_context, const char *, krb5_const_principal, set_result_f, void *); } krb5plugin_an2ln_ftable; #endif /* HEIMDAL_KRB5_AN2LN_PLUGIN_H */ pykrb5-0.8.0/build_helpers/heimdal/include/krb5/ccache_plugin.h000066400000000000000000000032601505521762700244150ustar00rootroot00000000000000/*********************************************************************** * Copyright (c) 2010, Secure Endpoints Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * OF THE POSSIBILITY OF SUCH DAMAGE. * **********************************************************************/ #ifndef HEIMDAL_KRB5_CCACHE_PLUGIN_H #define HEIMDAL_KRB5_CCACHE_PLUGIN_H 1 #include #define KRB5_PLUGIN_CCACHE "ccache_ops" #endif /* HEIMDAL_KRB5_CCACHE_PLUGIN_H */ pykrb5-0.8.0/build_helpers/heimdal/include/krb5/db_plugin.h000066400000000000000000000047521505521762700236030ustar00rootroot00000000000000/* * Copyright (c) 2011, Secure Endpoints Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * OF THE POSSIBILITY OF SUCH DAMAGE. */ /* $Id$ */ #ifndef HEIMDAL_KRB5_DB_PLUGIN_H #define HEIMDAL_KRB5_DB_PLUGIN_H 1 #define KRB5_PLUGIN_DB "krb5_db_plug" #define KRB5_PLUGIN_DB_VERSION_0 0 /** @struct krb5plugin_db_ftable_desc * * @brief Description of the krb5 DB plugin facility. * * The krb5_aname_to_lname(3) function's DB rule is pluggable. The * plugin is named KRB5_PLUGIN_DB ("krb5_db_plug"), with a single minor * version, KRB5_PLUGIN_DB_VERSION_0 (0). * * The plugin consists of a data symbol referencing a structure of type * krb5plugin_db_ftable_desc, with three fields: * * @param init Plugin initialization function (see krb5-plugin(7)) * * @param minor_version The plugin minor version number (0) * * @param fini Plugin finalization function * * The init entry point is expected to call heim_db_register(). The * fini entry point is expected to do nothing. * * @ingroup krb5_support */ typedef struct krb5plugin_db_ftable_desc { int minor_version; krb5_error_code (KRB5_LIB_CALL *init)(krb5_context, void **); void (KRB5_LIB_CALL *fini)(void *); } krb5plugin_db_ftable; #endif /* HEIMDAL_KRB5_DB_PLUGIN_H */ pykrb5-0.8.0/build_helpers/heimdal/include/krb5/locate_plugin.h000066400000000000000000000056211505521762700244610ustar00rootroot00000000000000/* * Copyright (c) 2006 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Portions Copyright (c) 2010 Apple Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef HEIMDAL_KRB5_LOCATE_PLUGIN_H #define HEIMDAL_KRB5_LOCATE_PLUGIN_H 1 #define KRB5_PLUGIN_LOCATE "service_locator" #define KRB5_PLUGIN_LOCATE_VERSION 1 #define KRB5_PLUGIN_LOCATE_VERSION_0 0 #define KRB5_PLUGIN_LOCATE_VERSION_1 1 #define KRB5_PLUGIN_LOCATE_VERSION_2 2 enum locate_service_type { locate_service_kdc = 1, locate_service_master_kdc, locate_service_kadmin, locate_service_krb524, locate_service_kpasswd }; typedef krb5_error_code (*krb5plugin_service_locate_lookup) (void *, unsigned long, enum locate_service_type, const char *, int, int, int (*)(void *,int,struct sockaddr *), void *); #define KRB5_PLF_ALLOW_HOMEDIR 1 typedef krb5_error_code (*krb5plugin_service_locate_lookup_old) (void *, enum locate_service_type, const char *, int, int, int (*)(void *,int,struct sockaddr *), void *); typedef struct krb5plugin_service_locate_ftable { int minor_version; krb5_error_code (*init)(krb5_context, void **); void (*fini)(void *); krb5plugin_service_locate_lookup_old old_lookup; krb5plugin_service_locate_lookup lookup; /* version 2 */ } krb5plugin_service_locate_ftable; #endif /* HEIMDAL_KRB5_LOCATE_PLUGIN_H */ pykrb5-0.8.0/build_helpers/heimdal/include/krb5/send_to_kdc_plugin.h000066400000000000000000000051771505521762700254740ustar00rootroot00000000000000/* * Copyright (c) 2008 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef HEIMDAL_KRB5_SEND_TO_KDC_PLUGIN_H #define HEIMDAL_KRB5_SEND_TO_KDC_PLUGIN_H 1 #include #define KRB5_PLUGIN_SEND_TO_KDC "send_to_kdc" #define KRB5_PLUGIN_SEND_TO_KDC_VERSION_0 0 #define KRB5_PLUGIN_SEND_TO_KDC_VERSION_2 2 #define KRB5_PLUGIN_SEND_TO_KDC_VERSION KRB5_PLUGIN_SEND_TO_KDC_VERSION_2 typedef krb5_error_code (*krb5plugin_send_to_kdc_func)(krb5_context, void *, krb5_krbhst_info *, time_t timeout, const krb5_data *, krb5_data *); typedef krb5_error_code (*krb5plugin_send_to_realm_func)(krb5_context, void *, krb5_const_realm, time_t timeout, const krb5_data *, krb5_data *); typedef struct krb5plugin_send_to_kdc_ftable { int minor_version; krb5_error_code (*init)(krb5_context, void **); void (*fini)(void *); krb5plugin_send_to_kdc_func send_to_kdc; krb5plugin_send_to_realm_func send_to_realm; /* added in version 2 */ } krb5plugin_send_to_kdc_ftable; #endif /* HEIMDAL_KRB5_SEND_TO_KDC_PLUGIN_H */ pykrb5-0.8.0/build_helpers/heimdal/include/krb5/windc_plugin.h000066400000000000000000000062761505521762700243250ustar00rootroot00000000000000/* * Copyright (c) 2006 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef HEIMDAL_KRB5_PAC_PLUGIN_H #define HEIMDAL_KRB5_PAC_PLUGIN_H 1 #include /* * The PAC generate function should allocate a krb5_pac using * krb5_pac_init and fill in the PAC structure for the principal using * krb5_pac_add_buffer. * * The PAC verify function should verify all components in the PAC * using krb5_pac_get_types and krb5_pac_get_buffer for all types. * * Check client access function check if the client is authorized. */ struct hdb_entry_ex; typedef krb5_error_code (*krb5plugin_windc_pac_generate)(void *, krb5_context, struct hdb_entry_ex *, krb5_pac *); typedef krb5_error_code (*krb5plugin_windc_pac_verify)(void *, krb5_context, const krb5_principal, /* new ticket client */ const krb5_principal, /* delegation proxy */ struct hdb_entry_ex *,/* client */ struct hdb_entry_ex *,/* server */ struct hdb_entry_ex *,/* krbtgt */ krb5_pac *); typedef krb5_error_code (*krb5plugin_windc_client_access)( void *, krb5_context, krb5_kdc_configuration *config, hdb_entry_ex *, const char *, hdb_entry_ex *, const char *, KDC_REQ *, METHOD_DATA *); #define KRB5_WINDC_PLUGIN_MINOR 6 #define KRB5_WINDC_PLUGING_MINOR KRB5_WINDC_PLUGIN_MINOR typedef struct krb5plugin_windc_ftable { int minor_version; krb5_error_code (*init)(krb5_context, void **); void (*fini)(void *); krb5plugin_windc_pac_generate pac_generate; krb5plugin_windc_pac_verify pac_verify; krb5plugin_windc_client_access client_access; } krb5plugin_windc_ftable; #endif /* HEIMDAL_KRB5_PAC_PLUGIN_H */ pykrb5-0.8.0/build_helpers/heimdal/include/krb5_asn1.h000066400000000000000000002402561505521762700225630ustar00rootroot00000000000000/* Generated from ./krb5.asn1 */ /* Do not edit */ #ifndef __krb5_asn1_h__ #define __krb5_asn1_h__ #include #include #ifndef __asn1_common_definitions__ #define __asn1_common_definitions__ #ifndef __HEIM_BASE_DATA__ #define __HEIM_BASE_DATA__ 1 struct heim_base_data { size_t length; void *data; }; typedef struct heim_base_data heim_octet_string; #endif typedef struct heim_integer { size_t length; void *data; int negative; } heim_integer; typedef char *heim_general_string; typedef char *heim_utf8_string; typedef struct heim_base_data heim_printable_string; typedef struct heim_base_data heim_ia5_string; typedef struct heim_bmp_string { size_t length; uint16_t *data; } heim_bmp_string; typedef struct heim_universal_string { size_t length; uint32_t *data; } heim_universal_string; typedef char *heim_visible_string; typedef struct heim_oid { size_t length; unsigned *components; } heim_oid; typedef struct heim_bit_string { size_t length; void *data; } heim_bit_string; typedef struct heim_base_data heim_any; typedef struct heim_base_data heim_any_set; #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \ do { \ (BL) = length_##T((S)); \ (B) = malloc((BL)); \ if((B) == NULL) { \ (R) = ENOMEM; \ } else { \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (S), (L)); \ if((R) != 0) { \ free((B)); \ (B) = NULL; \ } \ } \ } while (0) #ifdef _WIN32 #ifndef ASN1_LIB #define ASN1EXP __declspec(dllimport) #else #define ASN1EXP #endif #define ASN1CALL __stdcall #else #define ASN1EXP #define ASN1CALL #endif struct units; #endif /* NAME-TYPE ::= INTEGER { KRB5_NT_UNKNOWN(0), KRB5_NT_PRINCIPAL(1), KRB5_NT_SRV_INST(2), KRB5_NT_SRV_HST(3), KRB5_NT_SRV_XHST(4), KRB5_NT_UID(5), KRB5_NT_X500_PRINCIPAL(6), KRB5_NT_SMTP_NAME(7), KRB5_NT_ENTERPRISE_PRINCIPAL(10), KRB5_NT_WELLKNOWN(11), KRB5_NT_SRV_HST_DOMAIN(12), KRB5_NT_ENT_PRINCIPAL_AND_ID(-130), KRB5_NT_MS_PRINCIPAL(-128), KRB5_NT_MS_PRINCIPAL_AND_ID(-129), KRB5_NT_NTLM(-1200), KRB5_NT_X509_GENERAL_NAME(-1201), KRB5_NT_GSS_HOSTBASED_SERVICE(-1202), KRB5_NT_CACHE_UUID(-1203), KRB5_NT_SRV_HST_NEEDS_CANON(-195894762) } */ typedef enum NAME_TYPE { KRB5_NT_UNKNOWN = 0, KRB5_NT_PRINCIPAL = 1, KRB5_NT_SRV_INST = 2, KRB5_NT_SRV_HST = 3, KRB5_NT_SRV_XHST = 4, KRB5_NT_UID = 5, KRB5_NT_X500_PRINCIPAL = 6, KRB5_NT_SMTP_NAME = 7, KRB5_NT_ENTERPRISE_PRINCIPAL = 10, KRB5_NT_WELLKNOWN = 11, KRB5_NT_SRV_HST_DOMAIN = 12, KRB5_NT_ENT_PRINCIPAL_AND_ID = -130, KRB5_NT_MS_PRINCIPAL = -128, KRB5_NT_MS_PRINCIPAL_AND_ID = -129, KRB5_NT_NTLM = -1200, KRB5_NT_X509_GENERAL_NAME = -1201, KRB5_NT_GSS_HOSTBASED_SERVICE = -1202, KRB5_NT_CACHE_UUID = -1203, KRB5_NT_SRV_HST_NEEDS_CANON = -195894762 } NAME_TYPE; ASN1EXP int ASN1CALL decode_NAME_TYPE(const unsigned char *, size_t, NAME_TYPE *, size_t *); ASN1EXP int ASN1CALL encode_NAME_TYPE(unsigned char *, size_t, const NAME_TYPE *, size_t *); ASN1EXP size_t ASN1CALL length_NAME_TYPE(const NAME_TYPE *); ASN1EXP int ASN1CALL copy_NAME_TYPE (const NAME_TYPE *, NAME_TYPE *); ASN1EXP void ASN1CALL free_NAME_TYPE (NAME_TYPE *); /* MESSAGE-TYPE ::= INTEGER { krb_as_req(10), krb_as_rep(11), krb_tgs_req(12), krb_tgs_rep(13), krb_ap_req(14), krb_ap_rep(15), krb_safe(20), krb_priv(21), krb_cred(22), krb_error(30) } */ typedef enum MESSAGE_TYPE { krb_as_req = 10, krb_as_rep = 11, krb_tgs_req = 12, krb_tgs_rep = 13, krb_ap_req = 14, krb_ap_rep = 15, krb_safe = 20, krb_priv = 21, krb_cred = 22, krb_error = 30 } MESSAGE_TYPE; /* PADATA-TYPE ::= INTEGER { KRB5_PADATA_NONE(0), KRB5_PADATA_TGS_REQ(1), KRB5_PADATA_AP_REQ(1), KRB5_PADATA_ENC_TIMESTAMP(2), KRB5_PADATA_PW_SALT(3), KRB5_PADATA_ENC_UNIX_TIME(5), KRB5_PADATA_SANDIA_SECUREID(6), KRB5_PADATA_SESAME(7), KRB5_PADATA_OSF_DCE(8), KRB5_PADATA_CYBERSAFE_SECUREID(9), KRB5_PADATA_AFS3_SALT(10), KRB5_PADATA_ETYPE_INFO(11), KRB5_PADATA_SAM_CHALLENGE(12), KRB5_PADATA_SAM_RESPONSE(13), KRB5_PADATA_PK_AS_REQ_19(14), KRB5_PADATA_PK_AS_REP_19(15), KRB5_PADATA_PK_AS_REQ_WIN(15), KRB5_PADATA_PK_AS_REQ(16), KRB5_PADATA_PK_AS_REP(17), KRB5_PADATA_PA_PK_OCSP_RESPONSE(18), KRB5_PADATA_ETYPE_INFO2(19), KRB5_PADATA_USE_SPECIFIED_KVNO(20), KRB5_PADATA_SVR_REFERRAL_INFO(20), KRB5_PADATA_SAM_REDIRECT(21), KRB5_PADATA_GET_FROM_TYPED_DATA(22), KRB5_PADATA_SAM_ETYPE_INFO(23), KRB5_PADATA_SERVER_REFERRAL(25), KRB5_PADATA_ALT_PRINC(24), KRB5_PADATA_SAM_CHALLENGE2(30), KRB5_PADATA_SAM_RESPONSE2(31), KRB5_PA_EXTRA_TGT(41), KRB5_PADATA_FX_FAST_ARMOR(71), KRB5_PADATA_TD_KRB_PRINCIPAL(102), KRB5_PADATA_PK_TD_TRUSTED_CERTIFIERS(104), KRB5_PADATA_PK_TD_CERTIFICATE_INDEX(105), KRB5_PADATA_TD_APP_DEFINED_ERROR(106), KRB5_PADATA_TD_REQ_NONCE(107), KRB5_PADATA_TD_REQ_SEQ(108), KRB5_PADATA_PA_PAC_REQUEST(128), KRB5_PADATA_FOR_USER(129), KRB5_PADATA_FOR_X509_USER(130), KRB5_PADATA_FOR_CHECK_DUPS(131), KRB5_PADATA_AS_CHECKSUM(132), KRB5_PADATA_PK_AS_09_BINDING(132), KRB5_PADATA_FX_COOKIE(133), KRB5_PADATA_AUTHENTICATION_SET(134), KRB5_PADATA_AUTH_SET_SELECTED(135), KRB5_PADATA_FX_FAST(136), KRB5_PADATA_FX_ERROR(137), KRB5_PADATA_ENCRYPTED_CHALLENGE(138), KRB5_PADATA_OTP_CHALLENGE(141), KRB5_PADATA_OTP_REQUEST(142), KBB5_PADATA_OTP_CONFIRM(143), KRB5_PADATA_OTP_PIN_CHANGE(144), KRB5_PADATA_EPAK_AS_REQ(145), KRB5_PADATA_EPAK_AS_REP(146), KRB5_PADATA_PKINIT_KX(147), KRB5_PADATA_PKU2U_NAME(148), KRB5_PADATA_REQ_ENC_PA_REP(149), KRB5_PADATA_SUPPORTED_ETYPES(165) } */ typedef enum PADATA_TYPE { KRB5_PADATA_NONE = 0, KRB5_PADATA_TGS_REQ = 1, KRB5_PADATA_AP_REQ = 1, KRB5_PADATA_ENC_TIMESTAMP = 2, KRB5_PADATA_PW_SALT = 3, KRB5_PADATA_ENC_UNIX_TIME = 5, KRB5_PADATA_SANDIA_SECUREID = 6, KRB5_PADATA_SESAME = 7, KRB5_PADATA_OSF_DCE = 8, KRB5_PADATA_CYBERSAFE_SECUREID = 9, KRB5_PADATA_AFS3_SALT = 10, KRB5_PADATA_ETYPE_INFO = 11, KRB5_PADATA_SAM_CHALLENGE = 12, KRB5_PADATA_SAM_RESPONSE = 13, KRB5_PADATA_PK_AS_REQ_19 = 14, KRB5_PADATA_PK_AS_REP_19 = 15, KRB5_PADATA_PK_AS_REQ_WIN = 15, KRB5_PADATA_PK_AS_REQ = 16, KRB5_PADATA_PK_AS_REP = 17, KRB5_PADATA_PA_PK_OCSP_RESPONSE = 18, KRB5_PADATA_ETYPE_INFO2 = 19, KRB5_PADATA_USE_SPECIFIED_KVNO = 20, KRB5_PADATA_SVR_REFERRAL_INFO = 20, KRB5_PADATA_SAM_REDIRECT = 21, KRB5_PADATA_GET_FROM_TYPED_DATA = 22, KRB5_PADATA_SAM_ETYPE_INFO = 23, KRB5_PADATA_SERVER_REFERRAL = 25, KRB5_PADATA_ALT_PRINC = 24, KRB5_PADATA_SAM_CHALLENGE2 = 30, KRB5_PADATA_SAM_RESPONSE2 = 31, KRB5_PA_EXTRA_TGT = 41, KRB5_PADATA_FX_FAST_ARMOR = 71, KRB5_PADATA_TD_KRB_PRINCIPAL = 102, KRB5_PADATA_PK_TD_TRUSTED_CERTIFIERS = 104, KRB5_PADATA_PK_TD_CERTIFICATE_INDEX = 105, KRB5_PADATA_TD_APP_DEFINED_ERROR = 106, KRB5_PADATA_TD_REQ_NONCE = 107, KRB5_PADATA_TD_REQ_SEQ = 108, KRB5_PADATA_PA_PAC_REQUEST = 128, KRB5_PADATA_FOR_USER = 129, KRB5_PADATA_FOR_X509_USER = 130, KRB5_PADATA_FOR_CHECK_DUPS = 131, KRB5_PADATA_AS_CHECKSUM = 132, KRB5_PADATA_PK_AS_09_BINDING = 132, KRB5_PADATA_FX_COOKIE = 133, KRB5_PADATA_AUTHENTICATION_SET = 134, KRB5_PADATA_AUTH_SET_SELECTED = 135, KRB5_PADATA_FX_FAST = 136, KRB5_PADATA_FX_ERROR = 137, KRB5_PADATA_ENCRYPTED_CHALLENGE = 138, KRB5_PADATA_OTP_CHALLENGE = 141, KRB5_PADATA_OTP_REQUEST = 142, KBB5_PADATA_OTP_CONFIRM = 143, KRB5_PADATA_OTP_PIN_CHANGE = 144, KRB5_PADATA_EPAK_AS_REQ = 145, KRB5_PADATA_EPAK_AS_REP = 146, KRB5_PADATA_PKINIT_KX = 147, KRB5_PADATA_PKU2U_NAME = 148, KRB5_PADATA_REQ_ENC_PA_REP = 149, KRB5_PADATA_SUPPORTED_ETYPES = 165 } PADATA_TYPE; ASN1EXP int ASN1CALL decode_PADATA_TYPE(const unsigned char *, size_t, PADATA_TYPE *, size_t *); ASN1EXP int ASN1CALL encode_PADATA_TYPE(unsigned char *, size_t, const PADATA_TYPE *, size_t *); ASN1EXP size_t ASN1CALL length_PADATA_TYPE(const PADATA_TYPE *); ASN1EXP int ASN1CALL copy_PADATA_TYPE (const PADATA_TYPE *, PADATA_TYPE *); ASN1EXP void ASN1CALL free_PADATA_TYPE (PADATA_TYPE *); /* AUTHDATA-TYPE ::= INTEGER { KRB5_AUTHDATA_IF_RELEVANT(1), KRB5_AUTHDATA_INTENDED_FOR_SERVER(2), KRB5_AUTHDATA_INTENDED_FOR_APPLICATION_CLASS(3), KRB5_AUTHDATA_KDC_ISSUED(4), KRB5_AUTHDATA_AND_OR(5), KRB5_AUTHDATA_MANDATORY_TICKET_EXTENSIONS(6), KRB5_AUTHDATA_IN_TICKET_EXTENSIONS(7), KRB5_AUTHDATA_MANDATORY_FOR_KDC(8), KRB5_AUTHDATA_INITIAL_VERIFIED_CAS(9), KRB5_AUTHDATA_OSF_DCE(64), KRB5_AUTHDATA_SESAME(65), KRB5_AUTHDATA_OSF_DCE_PKI_CERTID(66), KRB5_AUTHDATA_WIN2K_PAC(128), KRB5_AUTHDATA_GSS_API_ETYPE_NEGOTIATION(129), KRB5_AUTHDATA_SIGNTICKET_OLDER(-17), KRB5_AUTHDATA_SIGNTICKET_OLD(142), KRB5_AUTHDATA_SIGNTICKET(512) } */ typedef enum AUTHDATA_TYPE { KRB5_AUTHDATA_IF_RELEVANT = 1, KRB5_AUTHDATA_INTENDED_FOR_SERVER = 2, KRB5_AUTHDATA_INTENDED_FOR_APPLICATION_CLASS = 3, KRB5_AUTHDATA_KDC_ISSUED = 4, KRB5_AUTHDATA_AND_OR = 5, KRB5_AUTHDATA_MANDATORY_TICKET_EXTENSIONS = 6, KRB5_AUTHDATA_IN_TICKET_EXTENSIONS = 7, KRB5_AUTHDATA_MANDATORY_FOR_KDC = 8, KRB5_AUTHDATA_INITIAL_VERIFIED_CAS = 9, KRB5_AUTHDATA_OSF_DCE = 64, KRB5_AUTHDATA_SESAME = 65, KRB5_AUTHDATA_OSF_DCE_PKI_CERTID = 66, KRB5_AUTHDATA_WIN2K_PAC = 128, KRB5_AUTHDATA_GSS_API_ETYPE_NEGOTIATION = 129, KRB5_AUTHDATA_SIGNTICKET_OLDER = -17, KRB5_AUTHDATA_SIGNTICKET_OLD = 142, KRB5_AUTHDATA_SIGNTICKET = 512 } AUTHDATA_TYPE; ASN1EXP int ASN1CALL decode_AUTHDATA_TYPE(const unsigned char *, size_t, AUTHDATA_TYPE *, size_t *); ASN1EXP int ASN1CALL encode_AUTHDATA_TYPE(unsigned char *, size_t, const AUTHDATA_TYPE *, size_t *); ASN1EXP size_t ASN1CALL length_AUTHDATA_TYPE(const AUTHDATA_TYPE *); ASN1EXP int ASN1CALL copy_AUTHDATA_TYPE (const AUTHDATA_TYPE *, AUTHDATA_TYPE *); ASN1EXP void ASN1CALL free_AUTHDATA_TYPE (AUTHDATA_TYPE *); /* CKSUMTYPE ::= INTEGER { CKSUMTYPE_NONE(0), CKSUMTYPE_CRC32(1), CKSUMTYPE_RSA_MD4(2), CKSUMTYPE_RSA_MD4_DES(3), CKSUMTYPE_DES_MAC(4), CKSUMTYPE_DES_MAC_K(5), CKSUMTYPE_RSA_MD4_DES_K(6), CKSUMTYPE_RSA_MD5(7), CKSUMTYPE_RSA_MD5_DES(8), CKSUMTYPE_RSA_MD5_DES3(9), CKSUMTYPE_SHA1_OTHER(10), CKSUMTYPE_HMAC_SHA1_DES3(12), CKSUMTYPE_SHA1(14), CKSUMTYPE_HMAC_SHA1_96_AES_128(15), CKSUMTYPE_HMAC_SHA1_96_AES_256(16), CKSUMTYPE_HMAC_SHA256_128_AES128(19), CKSUMTYPE_HMAC_SHA384_192_AES256(20), CKSUMTYPE_GSSAPI(32771), CKSUMTYPE_HMAC_MD5(-138), CKSUMTYPE_HMAC_MD5_ENC(-1138) } */ typedef enum CKSUMTYPE { CKSUMTYPE_NONE = 0, CKSUMTYPE_CRC32 = 1, CKSUMTYPE_RSA_MD4 = 2, CKSUMTYPE_RSA_MD4_DES = 3, CKSUMTYPE_DES_MAC = 4, CKSUMTYPE_DES_MAC_K = 5, CKSUMTYPE_RSA_MD4_DES_K = 6, CKSUMTYPE_RSA_MD5 = 7, CKSUMTYPE_RSA_MD5_DES = 8, CKSUMTYPE_RSA_MD5_DES3 = 9, CKSUMTYPE_SHA1_OTHER = 10, CKSUMTYPE_HMAC_SHA1_DES3 = 12, CKSUMTYPE_SHA1 = 14, CKSUMTYPE_HMAC_SHA1_96_AES_128 = 15, CKSUMTYPE_HMAC_SHA1_96_AES_256 = 16, CKSUMTYPE_HMAC_SHA256_128_AES128 = 19, CKSUMTYPE_HMAC_SHA384_192_AES256 = 20, CKSUMTYPE_GSSAPI = 32771, CKSUMTYPE_HMAC_MD5 = -138, CKSUMTYPE_HMAC_MD5_ENC = -1138 } CKSUMTYPE; ASN1EXP int ASN1CALL decode_CKSUMTYPE(const unsigned char *, size_t, CKSUMTYPE *, size_t *); ASN1EXP int ASN1CALL encode_CKSUMTYPE(unsigned char *, size_t, const CKSUMTYPE *, size_t *); ASN1EXP size_t ASN1CALL length_CKSUMTYPE(const CKSUMTYPE *); ASN1EXP int ASN1CALL copy_CKSUMTYPE (const CKSUMTYPE *, CKSUMTYPE *); ASN1EXP void ASN1CALL free_CKSUMTYPE (CKSUMTYPE *); /* ENCTYPE ::= INTEGER { KRB5_ENCTYPE_NULL(0), KRB5_ENCTYPE_DES_CBC_CRC(1), KRB5_ENCTYPE_DES_CBC_MD4(2), KRB5_ENCTYPE_DES_CBC_MD5(3), KRB5_ENCTYPE_DES3_CBC_MD5(5), KRB5_ENCTYPE_OLD_DES3_CBC_SHA1(7), KRB5_ENCTYPE_SIGN_DSA_GENERATE(8), KRB5_ENCTYPE_ENCRYPT_RSA_PRIV(9), KRB5_ENCTYPE_ENCRYPT_RSA_PUB(10), KRB5_ENCTYPE_DES3_CBC_SHA1(16), KRB5_ENCTYPE_AES128_CTS_HMAC_SHA1_96(17), KRB5_ENCTYPE_AES256_CTS_HMAC_SHA1_96(18), KRB5_ENCTYPE_AES128_CTS_HMAC_SHA256_128(19), KRB5_ENCTYPE_AES256_CTS_HMAC_SHA384_192(20), KRB5_ENCTYPE_ARCFOUR_HMAC_MD5(23), KRB5_ENCTYPE_ARCFOUR_HMAC_MD5_56(24), KRB5_ENCTYPE_ENCTYPE_PK_CROSS(48), KRB5_ENCTYPE_ARCFOUR_MD4(-128), KRB5_ENCTYPE_ARCFOUR_HMAC_OLD(-133), KRB5_ENCTYPE_ARCFOUR_HMAC_OLD_EXP(-135), KRB5_ENCTYPE_DES_CBC_NONE(-4096), KRB5_ENCTYPE_DES3_CBC_NONE(-4097), KRB5_ENCTYPE_DES_CFB64_NONE(-4098), KRB5_ENCTYPE_DES_PCBC_NONE(-4099), KRB5_ENCTYPE_DIGEST_MD5_NONE(-4100), KRB5_ENCTYPE_CRAM_MD5_NONE(-4101) } */ typedef enum ENCTYPE { KRB5_ENCTYPE_NULL = 0, KRB5_ENCTYPE_DES_CBC_CRC = 1, KRB5_ENCTYPE_DES_CBC_MD4 = 2, KRB5_ENCTYPE_DES_CBC_MD5 = 3, KRB5_ENCTYPE_DES3_CBC_MD5 = 5, KRB5_ENCTYPE_OLD_DES3_CBC_SHA1 = 7, KRB5_ENCTYPE_SIGN_DSA_GENERATE = 8, KRB5_ENCTYPE_ENCRYPT_RSA_PRIV = 9, KRB5_ENCTYPE_ENCRYPT_RSA_PUB = 10, KRB5_ENCTYPE_DES3_CBC_SHA1 = 16, KRB5_ENCTYPE_AES128_CTS_HMAC_SHA1_96 = 17, KRB5_ENCTYPE_AES256_CTS_HMAC_SHA1_96 = 18, KRB5_ENCTYPE_AES128_CTS_HMAC_SHA256_128 = 19, KRB5_ENCTYPE_AES256_CTS_HMAC_SHA384_192 = 20, KRB5_ENCTYPE_ARCFOUR_HMAC_MD5 = 23, KRB5_ENCTYPE_ARCFOUR_HMAC_MD5_56 = 24, KRB5_ENCTYPE_ENCTYPE_PK_CROSS = 48, KRB5_ENCTYPE_ARCFOUR_MD4 = -128, KRB5_ENCTYPE_ARCFOUR_HMAC_OLD = -133, KRB5_ENCTYPE_ARCFOUR_HMAC_OLD_EXP = -135, KRB5_ENCTYPE_DES_CBC_NONE = -4096, KRB5_ENCTYPE_DES3_CBC_NONE = -4097, KRB5_ENCTYPE_DES_CFB64_NONE = -4098, KRB5_ENCTYPE_DES_PCBC_NONE = -4099, KRB5_ENCTYPE_DIGEST_MD5_NONE = -4100, KRB5_ENCTYPE_CRAM_MD5_NONE = -4101 } ENCTYPE; ASN1EXP int ASN1CALL decode_ENCTYPE(const unsigned char *, size_t, ENCTYPE *, size_t *); ASN1EXP int ASN1CALL encode_ENCTYPE(unsigned char *, size_t, const ENCTYPE *, size_t *); ASN1EXP size_t ASN1CALL length_ENCTYPE(const ENCTYPE *); ASN1EXP int ASN1CALL copy_ENCTYPE (const ENCTYPE *, ENCTYPE *); ASN1EXP void ASN1CALL free_ENCTYPE (ENCTYPE *); /* krb5uint32 ::= INTEGER (0..4294967295) */ typedef unsigned int krb5uint32; /* krb5int32 ::= INTEGER (-2147483648..2147483647) */ typedef int krb5int32; /* KerberosString ::= GeneralString */ typedef heim_general_string KerberosString; ASN1EXP int ASN1CALL decode_KerberosString(const unsigned char *, size_t, KerberosString *, size_t *); ASN1EXP int ASN1CALL encode_KerberosString(unsigned char *, size_t, const KerberosString *, size_t *); ASN1EXP size_t ASN1CALL length_KerberosString(const KerberosString *); ASN1EXP int ASN1CALL copy_KerberosString (const KerberosString *, KerberosString *); ASN1EXP void ASN1CALL free_KerberosString (KerberosString *); /* Realm ::= GeneralString */ typedef heim_general_string Realm; ASN1EXP int ASN1CALL decode_Realm(const unsigned char *, size_t, Realm *, size_t *); ASN1EXP int ASN1CALL encode_Realm(unsigned char *, size_t, const Realm *, size_t *); ASN1EXP size_t ASN1CALL length_Realm(const Realm *); ASN1EXP int ASN1CALL copy_Realm (const Realm *, Realm *); ASN1EXP void ASN1CALL free_Realm (Realm *); /* PrincipalName ::= SEQUENCE { name-type [0] NAME-TYPE, name-string [1] SEQUENCE OF GeneralString, } */ typedef struct PrincipalName { NAME_TYPE name_type; struct PrincipalName_name_string { unsigned int len; heim_general_string *val; } name_string; } PrincipalName; ASN1EXP int ASN1CALL decode_PrincipalName(const unsigned char *, size_t, PrincipalName *, size_t *); ASN1EXP int ASN1CALL encode_PrincipalName(unsigned char *, size_t, const PrincipalName *, size_t *); ASN1EXP size_t ASN1CALL length_PrincipalName(const PrincipalName *); ASN1EXP int ASN1CALL copy_PrincipalName (const PrincipalName *, PrincipalName *); ASN1EXP void ASN1CALL free_PrincipalName (PrincipalName *); /* Principal ::= SEQUENCE { name [0] PrincipalName, realm [1] Realm, } */ typedef struct Principal { PrincipalName name; Realm realm; } Principal; ASN1EXP int ASN1CALL decode_Principal(const unsigned char *, size_t, Principal *, size_t *); ASN1EXP int ASN1CALL encode_Principal(unsigned char *, size_t, const Principal *, size_t *); ASN1EXP size_t ASN1CALL length_Principal(const Principal *); ASN1EXP int ASN1CALL copy_Principal (const Principal *, Principal *); ASN1EXP void ASN1CALL free_Principal (Principal *); /* Principals ::= SEQUENCE OF Principal */ typedef struct Principals { unsigned int len; Principal *val; } Principals; ASN1EXP int ASN1CALL add_Principals (Principals *, const Principal *); ASN1EXP int ASN1CALL remove_Principals (Principals *, unsigned int); ASN1EXP int ASN1CALL decode_Principals(const unsigned char *, size_t, Principals *, size_t *); ASN1EXP int ASN1CALL encode_Principals(unsigned char *, size_t, const Principals *, size_t *); ASN1EXP size_t ASN1CALL length_Principals(const Principals *); ASN1EXP int ASN1CALL copy_Principals (const Principals *, Principals *); ASN1EXP void ASN1CALL free_Principals (Principals *); /* HostAddress ::= SEQUENCE { addr-type [0] krb5int32, address [1] OCTET STRING, } */ typedef struct HostAddress { krb5int32 addr_type; heim_octet_string address; } HostAddress; ASN1EXP int ASN1CALL decode_HostAddress(const unsigned char *, size_t, HostAddress *, size_t *); ASN1EXP int ASN1CALL encode_HostAddress(unsigned char *, size_t, const HostAddress *, size_t *); ASN1EXP size_t ASN1CALL length_HostAddress(const HostAddress *); ASN1EXP int ASN1CALL copy_HostAddress (const HostAddress *, HostAddress *); ASN1EXP void ASN1CALL free_HostAddress (HostAddress *); /* HostAddresses ::= SEQUENCE OF HostAddress */ typedef struct HostAddresses { unsigned int len; HostAddress *val; } HostAddresses; ASN1EXP int ASN1CALL decode_HostAddresses(const unsigned char *, size_t, HostAddresses *, size_t *); ASN1EXP int ASN1CALL encode_HostAddresses(unsigned char *, size_t, const HostAddresses *, size_t *); ASN1EXP size_t ASN1CALL length_HostAddresses(const HostAddresses *); ASN1EXP int ASN1CALL copy_HostAddresses (const HostAddresses *, HostAddresses *); ASN1EXP void ASN1CALL free_HostAddresses (HostAddresses *); /* KerberosTime ::= GeneralizedTime */ typedef time_t KerberosTime; ASN1EXP int ASN1CALL decode_KerberosTime(const unsigned char *, size_t, KerberosTime *, size_t *); ASN1EXP int ASN1CALL encode_KerberosTime(unsigned char *, size_t, const KerberosTime *, size_t *); ASN1EXP size_t ASN1CALL length_KerberosTime(const KerberosTime *); ASN1EXP int ASN1CALL copy_KerberosTime (const KerberosTime *, KerberosTime *); ASN1EXP void ASN1CALL free_KerberosTime (KerberosTime *); /* AuthorizationDataElement ::= SEQUENCE { ad-type [0] krb5int32, ad-data [1] OCTET STRING, } */ typedef struct AuthorizationDataElement { krb5int32 ad_type; heim_octet_string ad_data; } AuthorizationDataElement; ASN1EXP int ASN1CALL decode_AuthorizationDataElement(const unsigned char *, size_t, AuthorizationDataElement *, size_t *); ASN1EXP int ASN1CALL encode_AuthorizationDataElement(unsigned char *, size_t, const AuthorizationDataElement *, size_t *); ASN1EXP size_t ASN1CALL length_AuthorizationDataElement(const AuthorizationDataElement *); ASN1EXP int ASN1CALL copy_AuthorizationDataElement (const AuthorizationDataElement *, AuthorizationDataElement *); ASN1EXP void ASN1CALL free_AuthorizationDataElement (AuthorizationDataElement *); /* AuthorizationData ::= SEQUENCE OF AuthorizationDataElement */ typedef struct AuthorizationData { unsigned int len; AuthorizationDataElement *val; } AuthorizationData; ASN1EXP int ASN1CALL add_AuthorizationData (AuthorizationData *, const AuthorizationDataElement *); ASN1EXP int ASN1CALL remove_AuthorizationData (AuthorizationData *, unsigned int); ASN1EXP int ASN1CALL decode_AuthorizationData(const unsigned char *, size_t, AuthorizationData *, size_t *); ASN1EXP int ASN1CALL encode_AuthorizationData(unsigned char *, size_t, const AuthorizationData *, size_t *); ASN1EXP size_t ASN1CALL length_AuthorizationData(const AuthorizationData *); ASN1EXP int ASN1CALL copy_AuthorizationData (const AuthorizationData *, AuthorizationData *); ASN1EXP void ASN1CALL free_AuthorizationData (AuthorizationData *); /* APOptions ::= BIT STRING { reserved(0), use-session-key(1), mutual-required(2) } */ typedef struct APOptions { unsigned int reserved:1; unsigned int use_session_key:1; unsigned int mutual_required:1; unsigned int _unused3:1; unsigned int _unused4:1; unsigned int _unused5:1; unsigned int _unused6:1; unsigned int _unused7:1; unsigned int _unused8:1; unsigned int _unused9:1; unsigned int _unused10:1; unsigned int _unused11:1; unsigned int _unused12:1; unsigned int _unused13:1; unsigned int _unused14:1; unsigned int _unused15:1; unsigned int _unused16:1; unsigned int _unused17:1; unsigned int _unused18:1; unsigned int _unused19:1; unsigned int _unused20:1; unsigned int _unused21:1; unsigned int _unused22:1; unsigned int _unused23:1; unsigned int _unused24:1; unsigned int _unused25:1; unsigned int _unused26:1; unsigned int _unused27:1; unsigned int _unused28:1; unsigned int _unused29:1; unsigned int _unused30:1; unsigned int _unused31:1; } APOptions; unsigned APOptions2int(APOptions); APOptions int2APOptions(unsigned); const struct units * asn1_APOptions_units(void); /* TicketFlags ::= BIT STRING { reserved(0), forwardable(1), forwarded(2), proxiable(3), proxy(4), may-postdate(5), postdated(6), invalid(7), renewable(8), initial(9), pre-authent(10), hw-authent(11), transited-policy-checked(12), ok-as-delegate(13), enc-pa-rep(15), anonymous(16) } */ typedef struct TicketFlags { unsigned int reserved:1; unsigned int forwardable:1; unsigned int forwarded:1; unsigned int proxiable:1; unsigned int proxy:1; unsigned int may_postdate:1; unsigned int postdated:1; unsigned int invalid:1; unsigned int renewable:1; unsigned int initial:1; unsigned int pre_authent:1; unsigned int hw_authent:1; unsigned int transited_policy_checked:1; unsigned int ok_as_delegate:1; unsigned int _unused14:1; unsigned int enc_pa_rep:1; unsigned int anonymous:1; unsigned int _unused17:1; unsigned int _unused18:1; unsigned int _unused19:1; unsigned int _unused20:1; unsigned int _unused21:1; unsigned int _unused22:1; unsigned int _unused23:1; unsigned int _unused24:1; unsigned int _unused25:1; unsigned int _unused26:1; unsigned int _unused27:1; unsigned int _unused28:1; unsigned int _unused29:1; unsigned int _unused30:1; unsigned int _unused31:1; } TicketFlags; unsigned TicketFlags2int(TicketFlags); TicketFlags int2TicketFlags(unsigned); const struct units * asn1_TicketFlags_units(void); ASN1EXP int ASN1CALL decode_TicketFlags(const unsigned char *, size_t, TicketFlags *, size_t *); ASN1EXP int ASN1CALL encode_TicketFlags(unsigned char *, size_t, const TicketFlags *, size_t *); ASN1EXP size_t ASN1CALL length_TicketFlags(const TicketFlags *); ASN1EXP int ASN1CALL copy_TicketFlags (const TicketFlags *, TicketFlags *); ASN1EXP void ASN1CALL free_TicketFlags (TicketFlags *); /* KDCOptions ::= BIT STRING { reserved(0), forwardable(1), forwarded(2), proxiable(3), proxy(4), allow-postdate(5), postdated(6), renewable(8), cname-in-addl-tkt(14), canonicalize(15), request-anonymous(16), disable-transited-check(26), renewable-ok(27), enc-tkt-in-skey(28), renew(30), validate(31) } */ typedef struct KDCOptions { unsigned int reserved:1; unsigned int forwardable:1; unsigned int forwarded:1; unsigned int proxiable:1; unsigned int proxy:1; unsigned int allow_postdate:1; unsigned int postdated:1; unsigned int _unused7:1; unsigned int renewable:1; unsigned int _unused9:1; unsigned int _unused10:1; unsigned int _unused11:1; unsigned int _unused12:1; unsigned int _unused13:1; unsigned int cname_in_addl_tkt:1; unsigned int canonicalize:1; unsigned int request_anonymous:1; unsigned int _unused17:1; unsigned int _unused18:1; unsigned int _unused19:1; unsigned int _unused20:1; unsigned int _unused21:1; unsigned int _unused22:1; unsigned int _unused23:1; unsigned int _unused24:1; unsigned int _unused25:1; unsigned int disable_transited_check:1; unsigned int renewable_ok:1; unsigned int enc_tkt_in_skey:1; unsigned int _unused29:1; unsigned int renew:1; unsigned int validate:1; } KDCOptions; unsigned KDCOptions2int(KDCOptions); KDCOptions int2KDCOptions(unsigned); const struct units * asn1_KDCOptions_units(void); ASN1EXP int ASN1CALL decode_KDCOptions(const unsigned char *, size_t, KDCOptions *, size_t *); ASN1EXP int ASN1CALL encode_KDCOptions(unsigned char *, size_t, const KDCOptions *, size_t *); ASN1EXP size_t ASN1CALL length_KDCOptions(const KDCOptions *); ASN1EXP int ASN1CALL copy_KDCOptions (const KDCOptions *, KDCOptions *); ASN1EXP void ASN1CALL free_KDCOptions (KDCOptions *); /* LR-TYPE ::= INTEGER { LR_NONE(0), LR_INITIAL_TGT(1), LR_INITIAL(2), LR_ISSUE_USE_TGT(3), LR_RENEWAL(4), LR_REQUEST(5), LR_PW_EXPTIME(6), LR_ACCT_EXPTIME(7) } */ typedef enum LR_TYPE { LR_NONE = 0, LR_INITIAL_TGT = 1, LR_INITIAL = 2, LR_ISSUE_USE_TGT = 3, LR_RENEWAL = 4, LR_REQUEST = 5, LR_PW_EXPTIME = 6, LR_ACCT_EXPTIME = 7 } LR_TYPE; ASN1EXP int ASN1CALL decode_LR_TYPE(const unsigned char *, size_t, LR_TYPE *, size_t *); ASN1EXP int ASN1CALL encode_LR_TYPE(unsigned char *, size_t, const LR_TYPE *, size_t *); ASN1EXP size_t ASN1CALL length_LR_TYPE(const LR_TYPE *); ASN1EXP int ASN1CALL copy_LR_TYPE (const LR_TYPE *, LR_TYPE *); ASN1EXP void ASN1CALL free_LR_TYPE (LR_TYPE *); /* LastReq ::= SEQUENCE OF SEQUENCE { lr-type [0] LR-TYPE, lr-value [1] KerberosTime, } */ typedef struct LastReq { unsigned int len; struct LastReq_val { LR_TYPE lr_type; KerberosTime lr_value; } *val; } LastReq; ASN1EXP int ASN1CALL decode_LastReq(const unsigned char *, size_t, LastReq *, size_t *); ASN1EXP int ASN1CALL encode_LastReq(unsigned char *, size_t, const LastReq *, size_t *); ASN1EXP size_t ASN1CALL length_LastReq(const LastReq *); ASN1EXP int ASN1CALL copy_LastReq (const LastReq *, LastReq *); ASN1EXP void ASN1CALL free_LastReq (LastReq *); /* EncryptedData ::= SEQUENCE { etype [0] ENCTYPE, kvno [1] krb5int32 OPTIONAL, cipher [2] OCTET STRING, } */ typedef struct EncryptedData { ENCTYPE etype; krb5int32 *kvno; heim_octet_string cipher; } EncryptedData; ASN1EXP int ASN1CALL decode_EncryptedData(const unsigned char *, size_t, EncryptedData *, size_t *); ASN1EXP int ASN1CALL encode_EncryptedData(unsigned char *, size_t, const EncryptedData *, size_t *); ASN1EXP size_t ASN1CALL length_EncryptedData(const EncryptedData *); ASN1EXP int ASN1CALL copy_EncryptedData (const EncryptedData *, EncryptedData *); ASN1EXP void ASN1CALL free_EncryptedData (EncryptedData *); /* EncryptionKey ::= SEQUENCE { keytype [0] krb5int32, keyvalue [1] OCTET STRING, } */ typedef struct EncryptionKey { krb5int32 keytype; heim_octet_string keyvalue; } EncryptionKey; ASN1EXP int ASN1CALL decode_EncryptionKey(const unsigned char *, size_t, EncryptionKey *, size_t *); ASN1EXP int ASN1CALL encode_EncryptionKey(unsigned char *, size_t, const EncryptionKey *, size_t *); ASN1EXP size_t ASN1CALL length_EncryptionKey(const EncryptionKey *); ASN1EXP int ASN1CALL copy_EncryptionKey (const EncryptionKey *, EncryptionKey *); ASN1EXP void ASN1CALL free_EncryptionKey (EncryptionKey *); /* TransitedEncoding ::= SEQUENCE { tr-type [0] krb5int32, contents [1] OCTET STRING, } */ typedef struct TransitedEncoding { krb5int32 tr_type; heim_octet_string contents; } TransitedEncoding; ASN1EXP int ASN1CALL decode_TransitedEncoding(const unsigned char *, size_t, TransitedEncoding *, size_t *); ASN1EXP int ASN1CALL encode_TransitedEncoding(unsigned char *, size_t, const TransitedEncoding *, size_t *); ASN1EXP size_t ASN1CALL length_TransitedEncoding(const TransitedEncoding *); ASN1EXP int ASN1CALL copy_TransitedEncoding (const TransitedEncoding *, TransitedEncoding *); ASN1EXP void ASN1CALL free_TransitedEncoding (TransitedEncoding *); /* Ticket ::= [APPLICATION 1] SEQUENCE { tkt-vno [0] krb5int32, realm [1] Realm, sname [2] PrincipalName, enc-part [3] EncryptedData, } */ typedef struct Ticket { krb5int32 tkt_vno; Realm realm; PrincipalName sname; EncryptedData enc_part; } Ticket; ASN1EXP int ASN1CALL decode_Ticket(const unsigned char *, size_t, Ticket *, size_t *); ASN1EXP int ASN1CALL encode_Ticket(unsigned char *, size_t, const Ticket *, size_t *); ASN1EXP size_t ASN1CALL length_Ticket(const Ticket *); ASN1EXP int ASN1CALL copy_Ticket (const Ticket *, Ticket *); ASN1EXP void ASN1CALL free_Ticket (Ticket *); /* EncTicketPart ::= [APPLICATION 3] SEQUENCE { flags [0] TicketFlags, key [1] EncryptionKey, crealm [2] Realm, cname [3] PrincipalName, transited [4] TransitedEncoding, authtime [5] KerberosTime, starttime [6] KerberosTime OPTIONAL, endtime [7] KerberosTime, renew-till [8] KerberosTime OPTIONAL, caddr [9] HostAddresses OPTIONAL, authorization-data [10] AuthorizationData OPTIONAL, } */ typedef struct EncTicketPart { TicketFlags flags; EncryptionKey key; Realm crealm; PrincipalName cname; TransitedEncoding transited; KerberosTime authtime; KerberosTime *starttime; KerberosTime endtime; KerberosTime *renew_till; HostAddresses *caddr; AuthorizationData *authorization_data; } EncTicketPart; ASN1EXP int ASN1CALL decode_EncTicketPart(const unsigned char *, size_t, EncTicketPart *, size_t *); ASN1EXP int ASN1CALL encode_EncTicketPart(unsigned char *, size_t, const EncTicketPart *, size_t *); ASN1EXP size_t ASN1CALL length_EncTicketPart(const EncTicketPart *); ASN1EXP int ASN1CALL copy_EncTicketPart (const EncTicketPart *, EncTicketPart *); ASN1EXP void ASN1CALL free_EncTicketPart (EncTicketPart *); /* Checksum ::= SEQUENCE { cksumtype [0] CKSUMTYPE, checksum [1] OCTET STRING, } */ typedef struct Checksum { CKSUMTYPE cksumtype; heim_octet_string checksum; } Checksum; ASN1EXP int ASN1CALL decode_Checksum(const unsigned char *, size_t, Checksum *, size_t *); ASN1EXP int ASN1CALL encode_Checksum(unsigned char *, size_t, const Checksum *, size_t *); ASN1EXP size_t ASN1CALL length_Checksum(const Checksum *); ASN1EXP int ASN1CALL copy_Checksum (const Checksum *, Checksum *); ASN1EXP void ASN1CALL free_Checksum (Checksum *); /* Authenticator ::= [APPLICATION 2] SEQUENCE { authenticator-vno [0] krb5int32, crealm [1] Realm, cname [2] PrincipalName, cksum [3] Checksum OPTIONAL, cusec [4] krb5int32, ctime [5] KerberosTime, subkey [6] EncryptionKey OPTIONAL, seq-number [7] krb5uint32 OPTIONAL, authorization-data [8] AuthorizationData OPTIONAL, } */ typedef struct Authenticator { krb5int32 authenticator_vno; Realm crealm; PrincipalName cname; Checksum *cksum; krb5int32 cusec; KerberosTime ctime; EncryptionKey *subkey; krb5uint32 *seq_number; AuthorizationData *authorization_data; } Authenticator; ASN1EXP int ASN1CALL decode_Authenticator(const unsigned char *, size_t, Authenticator *, size_t *); ASN1EXP int ASN1CALL encode_Authenticator(unsigned char *, size_t, const Authenticator *, size_t *); ASN1EXP size_t ASN1CALL length_Authenticator(const Authenticator *); ASN1EXP int ASN1CALL copy_Authenticator (const Authenticator *, Authenticator *); ASN1EXP void ASN1CALL free_Authenticator (Authenticator *); /* PA-DATA ::= SEQUENCE { padata-type [1] PADATA-TYPE, padata-value [2] OCTET STRING, } */ typedef struct PA_DATA { PADATA_TYPE padata_type; heim_octet_string padata_value; } PA_DATA; ASN1EXP int ASN1CALL decode_PA_DATA(const unsigned char *, size_t, PA_DATA *, size_t *); ASN1EXP int ASN1CALL encode_PA_DATA(unsigned char *, size_t, const PA_DATA *, size_t *); ASN1EXP size_t ASN1CALL length_PA_DATA(const PA_DATA *); ASN1EXP int ASN1CALL copy_PA_DATA (const PA_DATA *, PA_DATA *); ASN1EXP void ASN1CALL free_PA_DATA (PA_DATA *); /* ETYPE-INFO-ENTRY ::= SEQUENCE { etype [0] ENCTYPE, salt [1] OCTET STRING OPTIONAL, salttype [2] krb5int32 OPTIONAL, } */ typedef struct ETYPE_INFO_ENTRY { ENCTYPE etype; heim_octet_string *salt; krb5int32 *salttype; } ETYPE_INFO_ENTRY; ASN1EXP int ASN1CALL decode_ETYPE_INFO_ENTRY(const unsigned char *, size_t, ETYPE_INFO_ENTRY *, size_t *); ASN1EXP int ASN1CALL encode_ETYPE_INFO_ENTRY(unsigned char *, size_t, const ETYPE_INFO_ENTRY *, size_t *); ASN1EXP size_t ASN1CALL length_ETYPE_INFO_ENTRY(const ETYPE_INFO_ENTRY *); ASN1EXP int ASN1CALL copy_ETYPE_INFO_ENTRY (const ETYPE_INFO_ENTRY *, ETYPE_INFO_ENTRY *); ASN1EXP void ASN1CALL free_ETYPE_INFO_ENTRY (ETYPE_INFO_ENTRY *); /* ETYPE-INFO ::= SEQUENCE OF ETYPE-INFO-ENTRY */ typedef struct ETYPE_INFO { unsigned int len; ETYPE_INFO_ENTRY *val; } ETYPE_INFO; ASN1EXP int ASN1CALL add_ETYPE_INFO (ETYPE_INFO *, const ETYPE_INFO_ENTRY *); ASN1EXP int ASN1CALL remove_ETYPE_INFO (ETYPE_INFO *, unsigned int); ASN1EXP int ASN1CALL decode_ETYPE_INFO(const unsigned char *, size_t, ETYPE_INFO *, size_t *); ASN1EXP int ASN1CALL encode_ETYPE_INFO(unsigned char *, size_t, const ETYPE_INFO *, size_t *); ASN1EXP size_t ASN1CALL length_ETYPE_INFO(const ETYPE_INFO *); ASN1EXP int ASN1CALL copy_ETYPE_INFO (const ETYPE_INFO *, ETYPE_INFO *); ASN1EXP void ASN1CALL free_ETYPE_INFO (ETYPE_INFO *); /* ETYPE-INFO2-ENTRY ::= SEQUENCE { etype [0] ENCTYPE, salt [1] KerberosString OPTIONAL, s2kparams [2] OCTET STRING OPTIONAL, } */ typedef struct ETYPE_INFO2_ENTRY { ENCTYPE etype; KerberosString *salt; heim_octet_string *s2kparams; } ETYPE_INFO2_ENTRY; ASN1EXP int ASN1CALL decode_ETYPE_INFO2_ENTRY(const unsigned char *, size_t, ETYPE_INFO2_ENTRY *, size_t *); ASN1EXP int ASN1CALL encode_ETYPE_INFO2_ENTRY(unsigned char *, size_t, const ETYPE_INFO2_ENTRY *, size_t *); ASN1EXP size_t ASN1CALL length_ETYPE_INFO2_ENTRY(const ETYPE_INFO2_ENTRY *); ASN1EXP int ASN1CALL copy_ETYPE_INFO2_ENTRY (const ETYPE_INFO2_ENTRY *, ETYPE_INFO2_ENTRY *); ASN1EXP void ASN1CALL free_ETYPE_INFO2_ENTRY (ETYPE_INFO2_ENTRY *); /* ETYPE-INFO2 ::= SEQUENCE OF ETYPE-INFO2-ENTRY */ typedef struct ETYPE_INFO2 { unsigned int len; ETYPE_INFO2_ENTRY *val; } ETYPE_INFO2; ASN1EXP int ASN1CALL add_ETYPE_INFO2 (ETYPE_INFO2 *, const ETYPE_INFO2_ENTRY *); ASN1EXP int ASN1CALL remove_ETYPE_INFO2 (ETYPE_INFO2 *, unsigned int); ASN1EXP int ASN1CALL decode_ETYPE_INFO2(const unsigned char *, size_t, ETYPE_INFO2 *, size_t *); ASN1EXP int ASN1CALL encode_ETYPE_INFO2(unsigned char *, size_t, const ETYPE_INFO2 *, size_t *); ASN1EXP size_t ASN1CALL length_ETYPE_INFO2(const ETYPE_INFO2 *); ASN1EXP int ASN1CALL copy_ETYPE_INFO2 (const ETYPE_INFO2 *, ETYPE_INFO2 *); ASN1EXP void ASN1CALL free_ETYPE_INFO2 (ETYPE_INFO2 *); /* METHOD-DATA ::= SEQUENCE OF PA-DATA */ typedef struct METHOD_DATA { unsigned int len; PA_DATA *val; } METHOD_DATA; ASN1EXP int ASN1CALL add_METHOD_DATA (METHOD_DATA *, const PA_DATA *); ASN1EXP int ASN1CALL remove_METHOD_DATA (METHOD_DATA *, unsigned int); ASN1EXP int ASN1CALL decode_METHOD_DATA(const unsigned char *, size_t, METHOD_DATA *, size_t *); ASN1EXP int ASN1CALL encode_METHOD_DATA(unsigned char *, size_t, const METHOD_DATA *, size_t *); ASN1EXP size_t ASN1CALL length_METHOD_DATA(const METHOD_DATA *); ASN1EXP int ASN1CALL copy_METHOD_DATA (const METHOD_DATA *, METHOD_DATA *); ASN1EXP void ASN1CALL free_METHOD_DATA (METHOD_DATA *); /* TypedData ::= SEQUENCE { data-type [0] krb5int32, data-value [1] OCTET STRING OPTIONAL, } */ typedef struct TypedData { krb5int32 data_type; heim_octet_string *data_value; } TypedData; ASN1EXP int ASN1CALL decode_TypedData(const unsigned char *, size_t, TypedData *, size_t *); ASN1EXP int ASN1CALL encode_TypedData(unsigned char *, size_t, const TypedData *, size_t *); ASN1EXP size_t ASN1CALL length_TypedData(const TypedData *); ASN1EXP int ASN1CALL copy_TypedData (const TypedData *, TypedData *); ASN1EXP void ASN1CALL free_TypedData (TypedData *); /* TYPED-DATA ::= SEQUENCE OF TypedData */ typedef struct TYPED_DATA { unsigned int len; TypedData *val; } TYPED_DATA; /* KDC-REQ-BODY ::= SEQUENCE { kdc-options [0] KDCOptions, cname [1] PrincipalName OPTIONAL, realm [2] Realm, sname [3] PrincipalName OPTIONAL, from [4] KerberosTime OPTIONAL, till [5] KerberosTime OPTIONAL, rtime [6] KerberosTime OPTIONAL, nonce [7] krb5int32, etype [8] SEQUENCE OF ENCTYPE, addresses [9] HostAddresses OPTIONAL, enc-authorization-data [10] EncryptedData OPTIONAL, additional-tickets [11] SEQUENCE OF Ticket OPTIONAL, } */ typedef struct KDC_REQ_BODY { KDCOptions kdc_options; PrincipalName *cname; Realm realm; PrincipalName *sname; KerberosTime *from; KerberosTime *till; KerberosTime *rtime; krb5int32 nonce; struct KDC_REQ_BODY_etype { unsigned int len; ENCTYPE *val; } etype; HostAddresses *addresses; EncryptedData *enc_authorization_data; struct KDC_REQ_BODY_additional_tickets { unsigned int len; Ticket *val; } *additional_tickets; } KDC_REQ_BODY; ASN1EXP int ASN1CALL decode_KDC_REQ_BODY(const unsigned char *, size_t, KDC_REQ_BODY *, size_t *); ASN1EXP int ASN1CALL encode_KDC_REQ_BODY(unsigned char *, size_t, const KDC_REQ_BODY *, size_t *); ASN1EXP size_t ASN1CALL length_KDC_REQ_BODY(const KDC_REQ_BODY *); ASN1EXP int ASN1CALL copy_KDC_REQ_BODY (const KDC_REQ_BODY *, KDC_REQ_BODY *); ASN1EXP void ASN1CALL free_KDC_REQ_BODY (KDC_REQ_BODY *); /* KDC-REQ ::= SEQUENCE { pvno [1] krb5int32, msg-type [2] MESSAGE-TYPE, padata [3] METHOD-DATA OPTIONAL, req-body [4] KDC-REQ-BODY, } */ typedef struct KDC_REQ { krb5int32 pvno; MESSAGE_TYPE msg_type; METHOD_DATA *padata; KDC_REQ_BODY req_body; } KDC_REQ; /* AS-REQ ::= [APPLICATION 10] KDC-REQ */ typedef KDC_REQ AS_REQ; ASN1EXP int ASN1CALL decode_AS_REQ(const unsigned char *, size_t, AS_REQ *, size_t *); ASN1EXP int ASN1CALL encode_AS_REQ(unsigned char *, size_t, const AS_REQ *, size_t *); ASN1EXP size_t ASN1CALL length_AS_REQ(const AS_REQ *); ASN1EXP int ASN1CALL copy_AS_REQ (const AS_REQ *, AS_REQ *); ASN1EXP void ASN1CALL free_AS_REQ (AS_REQ *); /* TGS-REQ ::= [APPLICATION 12] KDC-REQ */ typedef KDC_REQ TGS_REQ; ASN1EXP int ASN1CALL decode_TGS_REQ(const unsigned char *, size_t, TGS_REQ *, size_t *); ASN1EXP int ASN1CALL encode_TGS_REQ(unsigned char *, size_t, const TGS_REQ *, size_t *); ASN1EXP size_t ASN1CALL length_TGS_REQ(const TGS_REQ *); ASN1EXP int ASN1CALL copy_TGS_REQ (const TGS_REQ *, TGS_REQ *); ASN1EXP void ASN1CALL free_TGS_REQ (TGS_REQ *); /* PA-ENC-TS-ENC ::= SEQUENCE { patimestamp [0] KerberosTime, pausec [1] krb5int32 OPTIONAL, } */ typedef struct PA_ENC_TS_ENC { KerberosTime patimestamp; krb5int32 *pausec; } PA_ENC_TS_ENC; ASN1EXP int ASN1CALL decode_PA_ENC_TS_ENC(const unsigned char *, size_t, PA_ENC_TS_ENC *, size_t *); ASN1EXP int ASN1CALL encode_PA_ENC_TS_ENC(unsigned char *, size_t, const PA_ENC_TS_ENC *, size_t *); ASN1EXP size_t ASN1CALL length_PA_ENC_TS_ENC(const PA_ENC_TS_ENC *); ASN1EXP int ASN1CALL copy_PA_ENC_TS_ENC (const PA_ENC_TS_ENC *, PA_ENC_TS_ENC *); ASN1EXP void ASN1CALL free_PA_ENC_TS_ENC (PA_ENC_TS_ENC *); /* PA-PAC-REQUEST ::= SEQUENCE { include-pac [0] BOOLEAN, } */ typedef struct PA_PAC_REQUEST { int include_pac; } PA_PAC_REQUEST; ASN1EXP int ASN1CALL decode_PA_PAC_REQUEST(const unsigned char *, size_t, PA_PAC_REQUEST *, size_t *); ASN1EXP int ASN1CALL encode_PA_PAC_REQUEST(unsigned char *, size_t, const PA_PAC_REQUEST *, size_t *); ASN1EXP size_t ASN1CALL length_PA_PAC_REQUEST(const PA_PAC_REQUEST *); ASN1EXP int ASN1CALL copy_PA_PAC_REQUEST (const PA_PAC_REQUEST *, PA_PAC_REQUEST *); ASN1EXP void ASN1CALL free_PA_PAC_REQUEST (PA_PAC_REQUEST *); /* PROV-SRV-LOCATION ::= GeneralString */ typedef heim_general_string PROV_SRV_LOCATION; /* KDC-REP ::= SEQUENCE { pvno [0] krb5int32, msg-type [1] MESSAGE-TYPE, padata [2] METHOD-DATA OPTIONAL, crealm [3] Realm, cname [4] PrincipalName, ticket [5] Ticket, enc-part [6] EncryptedData, } */ typedef struct KDC_REP { krb5int32 pvno; MESSAGE_TYPE msg_type; METHOD_DATA *padata; Realm crealm; PrincipalName cname; Ticket ticket; EncryptedData enc_part; } KDC_REP; ASN1EXP int ASN1CALL decode_KDC_REP(const unsigned char *, size_t, KDC_REP *, size_t *); ASN1EXP int ASN1CALL encode_KDC_REP(unsigned char *, size_t, const KDC_REP *, size_t *); ASN1EXP size_t ASN1CALL length_KDC_REP(const KDC_REP *); ASN1EXP int ASN1CALL copy_KDC_REP (const KDC_REP *, KDC_REP *); ASN1EXP void ASN1CALL free_KDC_REP (KDC_REP *); /* AS-REP ::= [APPLICATION 11] KDC-REP */ typedef KDC_REP AS_REP; ASN1EXP int ASN1CALL decode_AS_REP(const unsigned char *, size_t, AS_REP *, size_t *); ASN1EXP int ASN1CALL encode_AS_REP(unsigned char *, size_t, const AS_REP *, size_t *); ASN1EXP size_t ASN1CALL length_AS_REP(const AS_REP *); ASN1EXP int ASN1CALL copy_AS_REP (const AS_REP *, AS_REP *); ASN1EXP void ASN1CALL free_AS_REP (AS_REP *); /* TGS-REP ::= [APPLICATION 13] KDC-REP */ typedef KDC_REP TGS_REP; ASN1EXP int ASN1CALL decode_TGS_REP(const unsigned char *, size_t, TGS_REP *, size_t *); ASN1EXP int ASN1CALL encode_TGS_REP(unsigned char *, size_t, const TGS_REP *, size_t *); ASN1EXP size_t ASN1CALL length_TGS_REP(const TGS_REP *); ASN1EXP int ASN1CALL copy_TGS_REP (const TGS_REP *, TGS_REP *); ASN1EXP void ASN1CALL free_TGS_REP (TGS_REP *); /* EncKDCRepPart ::= SEQUENCE { key [0] EncryptionKey, last-req [1] LastReq, nonce [2] krb5int32, key-expiration [3] KerberosTime OPTIONAL, flags [4] TicketFlags, authtime [5] KerberosTime, starttime [6] KerberosTime OPTIONAL, endtime [7] KerberosTime, renew-till [8] KerberosTime OPTIONAL, srealm [9] Realm, sname [10] PrincipalName, caddr [11] HostAddresses OPTIONAL, encrypted-pa-data [12] METHOD-DATA OPTIONAL, } */ typedef struct EncKDCRepPart { EncryptionKey key; LastReq last_req; krb5int32 nonce; KerberosTime *key_expiration; TicketFlags flags; KerberosTime authtime; KerberosTime *starttime; KerberosTime endtime; KerberosTime *renew_till; Realm srealm; PrincipalName sname; HostAddresses *caddr; METHOD_DATA *encrypted_pa_data; } EncKDCRepPart; ASN1EXP int ASN1CALL decode_EncKDCRepPart(const unsigned char *, size_t, EncKDCRepPart *, size_t *); ASN1EXP int ASN1CALL encode_EncKDCRepPart(unsigned char *, size_t, const EncKDCRepPart *, size_t *); ASN1EXP size_t ASN1CALL length_EncKDCRepPart(const EncKDCRepPart *); ASN1EXP int ASN1CALL copy_EncKDCRepPart (const EncKDCRepPart *, EncKDCRepPart *); ASN1EXP void ASN1CALL free_EncKDCRepPart (EncKDCRepPart *); /* EncASRepPart ::= [APPLICATION 25] EncKDCRepPart */ typedef EncKDCRepPart EncASRepPart; ASN1EXP int ASN1CALL decode_EncASRepPart(const unsigned char *, size_t, EncASRepPart *, size_t *); ASN1EXP int ASN1CALL encode_EncASRepPart(unsigned char *, size_t, const EncASRepPart *, size_t *); ASN1EXP size_t ASN1CALL length_EncASRepPart(const EncASRepPart *); ASN1EXP int ASN1CALL copy_EncASRepPart (const EncASRepPart *, EncASRepPart *); ASN1EXP void ASN1CALL free_EncASRepPart (EncASRepPart *); /* EncTGSRepPart ::= [APPLICATION 26] EncKDCRepPart */ typedef EncKDCRepPart EncTGSRepPart; ASN1EXP int ASN1CALL decode_EncTGSRepPart(const unsigned char *, size_t, EncTGSRepPart *, size_t *); ASN1EXP int ASN1CALL encode_EncTGSRepPart(unsigned char *, size_t, const EncTGSRepPart *, size_t *); ASN1EXP size_t ASN1CALL length_EncTGSRepPart(const EncTGSRepPart *); ASN1EXP int ASN1CALL copy_EncTGSRepPart (const EncTGSRepPart *, EncTGSRepPart *); ASN1EXP void ASN1CALL free_EncTGSRepPart (EncTGSRepPart *); /* AP-REQ ::= [APPLICATION 14] SEQUENCE { pvno [0] krb5int32, msg-type [1] MESSAGE-TYPE, ap-options [2] APOptions, ticket [3] Ticket, authenticator [4] EncryptedData, } */ typedef struct AP_REQ { krb5int32 pvno; MESSAGE_TYPE msg_type; APOptions ap_options; Ticket ticket; EncryptedData authenticator; } AP_REQ; ASN1EXP int ASN1CALL decode_AP_REQ(const unsigned char *, size_t, AP_REQ *, size_t *); ASN1EXP int ASN1CALL encode_AP_REQ(unsigned char *, size_t, const AP_REQ *, size_t *); ASN1EXP size_t ASN1CALL length_AP_REQ(const AP_REQ *); ASN1EXP int ASN1CALL copy_AP_REQ (const AP_REQ *, AP_REQ *); ASN1EXP void ASN1CALL free_AP_REQ (AP_REQ *); /* AP-REP ::= [APPLICATION 15] SEQUENCE { pvno [0] krb5int32, msg-type [1] MESSAGE-TYPE, enc-part [2] EncryptedData, } */ typedef struct AP_REP { krb5int32 pvno; MESSAGE_TYPE msg_type; EncryptedData enc_part; } AP_REP; ASN1EXP int ASN1CALL decode_AP_REP(const unsigned char *, size_t, AP_REP *, size_t *); ASN1EXP int ASN1CALL encode_AP_REP(unsigned char *, size_t, const AP_REP *, size_t *); ASN1EXP size_t ASN1CALL length_AP_REP(const AP_REP *); ASN1EXP int ASN1CALL copy_AP_REP (const AP_REP *, AP_REP *); ASN1EXP void ASN1CALL free_AP_REP (AP_REP *); /* EncAPRepPart ::= [APPLICATION 27] SEQUENCE { ctime [0] KerberosTime, cusec [1] krb5int32, subkey [2] EncryptionKey OPTIONAL, seq-number [3] krb5uint32 OPTIONAL, } */ typedef struct EncAPRepPart { KerberosTime ctime; krb5int32 cusec; EncryptionKey *subkey; krb5uint32 *seq_number; } EncAPRepPart; ASN1EXP int ASN1CALL decode_EncAPRepPart(const unsigned char *, size_t, EncAPRepPart *, size_t *); ASN1EXP int ASN1CALL encode_EncAPRepPart(unsigned char *, size_t, const EncAPRepPart *, size_t *); ASN1EXP size_t ASN1CALL length_EncAPRepPart(const EncAPRepPart *); ASN1EXP int ASN1CALL copy_EncAPRepPart (const EncAPRepPart *, EncAPRepPart *); ASN1EXP void ASN1CALL free_EncAPRepPart (EncAPRepPart *); /* KRB-SAFE-BODY ::= SEQUENCE { user-data [0] OCTET STRING, timestamp [1] KerberosTime OPTIONAL, usec [2] krb5int32 OPTIONAL, seq-number [3] krb5uint32 OPTIONAL, s-address [4] HostAddress OPTIONAL, r-address [5] HostAddress OPTIONAL, } */ typedef struct KRB_SAFE_BODY { heim_octet_string user_data; KerberosTime *timestamp; krb5int32 *usec; krb5uint32 *seq_number; HostAddress *s_address; HostAddress *r_address; } KRB_SAFE_BODY; ASN1EXP int ASN1CALL decode_KRB_SAFE_BODY(const unsigned char *, size_t, KRB_SAFE_BODY *, size_t *); ASN1EXP int ASN1CALL encode_KRB_SAFE_BODY(unsigned char *, size_t, const KRB_SAFE_BODY *, size_t *); ASN1EXP size_t ASN1CALL length_KRB_SAFE_BODY(const KRB_SAFE_BODY *); ASN1EXP int ASN1CALL copy_KRB_SAFE_BODY (const KRB_SAFE_BODY *, KRB_SAFE_BODY *); ASN1EXP void ASN1CALL free_KRB_SAFE_BODY (KRB_SAFE_BODY *); /* KRB-SAFE ::= [APPLICATION 20] SEQUENCE { pvno [0] krb5int32, msg-type [1] MESSAGE-TYPE, safe-body [2] KRB-SAFE-BODY, cksum [3] Checksum, } */ typedef struct KRB_SAFE { krb5int32 pvno; MESSAGE_TYPE msg_type; KRB_SAFE_BODY safe_body; Checksum cksum; } KRB_SAFE; ASN1EXP int ASN1CALL decode_KRB_SAFE(const unsigned char *, size_t, KRB_SAFE *, size_t *); ASN1EXP int ASN1CALL encode_KRB_SAFE(unsigned char *, size_t, const KRB_SAFE *, size_t *); ASN1EXP size_t ASN1CALL length_KRB_SAFE(const KRB_SAFE *); ASN1EXP int ASN1CALL copy_KRB_SAFE (const KRB_SAFE *, KRB_SAFE *); ASN1EXP void ASN1CALL free_KRB_SAFE (KRB_SAFE *); /* KRB-PRIV ::= [APPLICATION 21] SEQUENCE { pvno [0] krb5int32, msg-type [1] MESSAGE-TYPE, enc-part [3] EncryptedData, } */ typedef struct KRB_PRIV { krb5int32 pvno; MESSAGE_TYPE msg_type; EncryptedData enc_part; } KRB_PRIV; ASN1EXP int ASN1CALL decode_KRB_PRIV(const unsigned char *, size_t, KRB_PRIV *, size_t *); ASN1EXP int ASN1CALL encode_KRB_PRIV(unsigned char *, size_t, const KRB_PRIV *, size_t *); ASN1EXP size_t ASN1CALL length_KRB_PRIV(const KRB_PRIV *); ASN1EXP int ASN1CALL copy_KRB_PRIV (const KRB_PRIV *, KRB_PRIV *); ASN1EXP void ASN1CALL free_KRB_PRIV (KRB_PRIV *); /* EncKrbPrivPart ::= [APPLICATION 28] SEQUENCE { user-data [0] OCTET STRING, timestamp [1] KerberosTime OPTIONAL, usec [2] krb5int32 OPTIONAL, seq-number [3] krb5uint32 OPTIONAL, s-address [4] HostAddress OPTIONAL, r-address [5] HostAddress OPTIONAL, } */ typedef struct EncKrbPrivPart { heim_octet_string user_data; KerberosTime *timestamp; krb5int32 *usec; krb5uint32 *seq_number; HostAddress *s_address; HostAddress *r_address; } EncKrbPrivPart; ASN1EXP int ASN1CALL decode_EncKrbPrivPart(const unsigned char *, size_t, EncKrbPrivPart *, size_t *); ASN1EXP int ASN1CALL encode_EncKrbPrivPart(unsigned char *, size_t, const EncKrbPrivPart *, size_t *); ASN1EXP size_t ASN1CALL length_EncKrbPrivPart(const EncKrbPrivPart *); ASN1EXP int ASN1CALL copy_EncKrbPrivPart (const EncKrbPrivPart *, EncKrbPrivPart *); ASN1EXP void ASN1CALL free_EncKrbPrivPart (EncKrbPrivPart *); /* KRB-CRED ::= [APPLICATION 22] SEQUENCE { pvno [0] krb5int32, msg-type [1] MESSAGE-TYPE, tickets [2] SEQUENCE OF Ticket, enc-part [3] EncryptedData, } */ typedef struct KRB_CRED { krb5int32 pvno; MESSAGE_TYPE msg_type; struct KRB_CRED_tickets { unsigned int len; Ticket *val; } tickets; EncryptedData enc_part; } KRB_CRED; ASN1EXP int ASN1CALL decode_KRB_CRED(const unsigned char *, size_t, KRB_CRED *, size_t *); ASN1EXP int ASN1CALL encode_KRB_CRED(unsigned char *, size_t, const KRB_CRED *, size_t *); ASN1EXP size_t ASN1CALL length_KRB_CRED(const KRB_CRED *); ASN1EXP int ASN1CALL copy_KRB_CRED (const KRB_CRED *, KRB_CRED *); ASN1EXP void ASN1CALL free_KRB_CRED (KRB_CRED *); /* KrbCredInfo ::= SEQUENCE { key [0] EncryptionKey, prealm [1] Realm OPTIONAL, pname [2] PrincipalName OPTIONAL, flags [3] TicketFlags OPTIONAL, authtime [4] KerberosTime OPTIONAL, starttime [5] KerberosTime OPTIONAL, endtime [6] KerberosTime OPTIONAL, renew-till [7] KerberosTime OPTIONAL, srealm [8] Realm OPTIONAL, sname [9] PrincipalName OPTIONAL, caddr [10] HostAddresses OPTIONAL, } */ typedef struct KrbCredInfo { EncryptionKey key; Realm *prealm; PrincipalName *pname; TicketFlags *flags; KerberosTime *authtime; KerberosTime *starttime; KerberosTime *endtime; KerberosTime *renew_till; Realm *srealm; PrincipalName *sname; HostAddresses *caddr; } KrbCredInfo; ASN1EXP int ASN1CALL decode_KrbCredInfo(const unsigned char *, size_t, KrbCredInfo *, size_t *); ASN1EXP int ASN1CALL encode_KrbCredInfo(unsigned char *, size_t, const KrbCredInfo *, size_t *); ASN1EXP size_t ASN1CALL length_KrbCredInfo(const KrbCredInfo *); ASN1EXP int ASN1CALL copy_KrbCredInfo (const KrbCredInfo *, KrbCredInfo *); ASN1EXP void ASN1CALL free_KrbCredInfo (KrbCredInfo *); /* EncKrbCredPart ::= [APPLICATION 29] SEQUENCE { ticket-info [0] SEQUENCE OF KrbCredInfo, nonce [1] krb5int32 OPTIONAL, timestamp [2] KerberosTime OPTIONAL, usec [3] krb5int32 OPTIONAL, s-address [4] HostAddress OPTIONAL, r-address [5] HostAddress OPTIONAL, } */ typedef struct EncKrbCredPart { struct EncKrbCredPart_ticket_info { unsigned int len; KrbCredInfo *val; } ticket_info; krb5int32 *nonce; KerberosTime *timestamp; krb5int32 *usec; HostAddress *s_address; HostAddress *r_address; } EncKrbCredPart; ASN1EXP int ASN1CALL decode_EncKrbCredPart(const unsigned char *, size_t, EncKrbCredPart *, size_t *); ASN1EXP int ASN1CALL encode_EncKrbCredPart(unsigned char *, size_t, const EncKrbCredPart *, size_t *); ASN1EXP size_t ASN1CALL length_EncKrbCredPart(const EncKrbCredPart *); ASN1EXP int ASN1CALL copy_EncKrbCredPart (const EncKrbCredPart *, EncKrbCredPart *); ASN1EXP void ASN1CALL free_EncKrbCredPart (EncKrbCredPart *); /* KRB-ERROR ::= [APPLICATION 30] SEQUENCE { pvno [0] krb5int32, msg-type [1] MESSAGE-TYPE, ctime [2] KerberosTime OPTIONAL, cusec [3] krb5int32 OPTIONAL, stime [4] KerberosTime, susec [5] krb5int32, error-code [6] krb5int32, crealm [7] Realm OPTIONAL, cname [8] PrincipalName OPTIONAL, realm [9] Realm, sname [10] PrincipalName, e-text [11] GeneralString OPTIONAL, e-data [12] OCTET STRING OPTIONAL, } */ typedef struct KRB_ERROR { krb5int32 pvno; MESSAGE_TYPE msg_type; KerberosTime *ctime; krb5int32 *cusec; KerberosTime stime; krb5int32 susec; krb5int32 error_code; Realm *crealm; PrincipalName *cname; Realm realm; PrincipalName sname; heim_general_string *e_text; heim_octet_string *e_data; } KRB_ERROR; ASN1EXP int ASN1CALL decode_KRB_ERROR(const unsigned char *, size_t, KRB_ERROR *, size_t *); ASN1EXP int ASN1CALL encode_KRB_ERROR(unsigned char *, size_t, const KRB_ERROR *, size_t *); ASN1EXP size_t ASN1CALL length_KRB_ERROR(const KRB_ERROR *); ASN1EXP int ASN1CALL copy_KRB_ERROR (const KRB_ERROR *, KRB_ERROR *); ASN1EXP void ASN1CALL free_KRB_ERROR (KRB_ERROR *); /* ChangePasswdDataMS ::= SEQUENCE { newpasswd [0] OCTET STRING, targname [1] PrincipalName OPTIONAL, targrealm [2] Realm OPTIONAL, } */ typedef struct ChangePasswdDataMS { heim_octet_string newpasswd; PrincipalName *targname; Realm *targrealm; } ChangePasswdDataMS; ASN1EXP int ASN1CALL decode_ChangePasswdDataMS(const unsigned char *, size_t, ChangePasswdDataMS *, size_t *); ASN1EXP int ASN1CALL encode_ChangePasswdDataMS(unsigned char *, size_t, const ChangePasswdDataMS *, size_t *); ASN1EXP size_t ASN1CALL length_ChangePasswdDataMS(const ChangePasswdDataMS *); ASN1EXP int ASN1CALL copy_ChangePasswdDataMS (const ChangePasswdDataMS *, ChangePasswdDataMS *); ASN1EXP void ASN1CALL free_ChangePasswdDataMS (ChangePasswdDataMS *); /* EtypeList ::= SEQUENCE OF ENCTYPE */ typedef struct EtypeList { unsigned int len; ENCTYPE *val; } EtypeList; ASN1EXP int ASN1CALL decode_EtypeList(const unsigned char *, size_t, EtypeList *, size_t *); ASN1EXP int ASN1CALL encode_EtypeList(unsigned char *, size_t, const EtypeList *, size_t *); ASN1EXP size_t ASN1CALL length_EtypeList(const EtypeList *); ASN1EXP int ASN1CALL copy_EtypeList (const EtypeList *, EtypeList *); ASN1EXP void ASN1CALL free_EtypeList (EtypeList *); enum { krb5_pvno = 5 }; enum { DOMAIN_X500_COMPRESS = 1 }; /* AD-IF-RELEVANT ::= AuthorizationData */ typedef AuthorizationData AD_IF_RELEVANT; ASN1EXP int ASN1CALL decode_AD_IF_RELEVANT(const unsigned char *, size_t, AD_IF_RELEVANT *, size_t *); ASN1EXP int ASN1CALL encode_AD_IF_RELEVANT(unsigned char *, size_t, const AD_IF_RELEVANT *, size_t *); ASN1EXP size_t ASN1CALL length_AD_IF_RELEVANT(const AD_IF_RELEVANT *); ASN1EXP int ASN1CALL copy_AD_IF_RELEVANT (const AD_IF_RELEVANT *, AD_IF_RELEVANT *); ASN1EXP void ASN1CALL free_AD_IF_RELEVANT (AD_IF_RELEVANT *); /* AD-KDCIssued ::= SEQUENCE { ad-checksum [0] Checksum, i-realm [1] Realm OPTIONAL, i-sname [2] PrincipalName OPTIONAL, elements [3] AuthorizationData, } */ typedef struct AD_KDCIssued { Checksum ad_checksum; Realm *i_realm; PrincipalName *i_sname; AuthorizationData elements; } AD_KDCIssued; ASN1EXP int ASN1CALL decode_AD_KDCIssued(const unsigned char *, size_t, AD_KDCIssued *, size_t *); ASN1EXP int ASN1CALL encode_AD_KDCIssued(unsigned char *, size_t, const AD_KDCIssued *, size_t *); ASN1EXP size_t ASN1CALL length_AD_KDCIssued(const AD_KDCIssued *); ASN1EXP int ASN1CALL copy_AD_KDCIssued (const AD_KDCIssued *, AD_KDCIssued *); ASN1EXP void ASN1CALL free_AD_KDCIssued (AD_KDCIssued *); /* AD-AND-OR ::= SEQUENCE { condition-count [0] INTEGER, elements [1] AuthorizationData, } */ typedef struct AD_AND_OR { heim_integer condition_count; AuthorizationData elements; } AD_AND_OR; ASN1EXP int ASN1CALL decode_AD_AND_OR(const unsigned char *, size_t, AD_AND_OR *, size_t *); ASN1EXP int ASN1CALL encode_AD_AND_OR(unsigned char *, size_t, const AD_AND_OR *, size_t *); ASN1EXP size_t ASN1CALL length_AD_AND_OR(const AD_AND_OR *); ASN1EXP int ASN1CALL copy_AD_AND_OR (const AD_AND_OR *, AD_AND_OR *); ASN1EXP void ASN1CALL free_AD_AND_OR (AD_AND_OR *); /* AD-MANDATORY-FOR-KDC ::= AuthorizationData */ typedef AuthorizationData AD_MANDATORY_FOR_KDC; /* PA-SAM-TYPE ::= INTEGER { PA_SAM_TYPE_ENIGMA(1), PA_SAM_TYPE_DIGI_PATH(2), PA_SAM_TYPE_SKEY_K0(3), PA_SAM_TYPE_SKEY(4), PA_SAM_TYPE_SECURID(5), PA_SAM_TYPE_CRYPTOCARD(6) } */ typedef enum PA_SAM_TYPE { PA_SAM_TYPE_ENIGMA = 1, PA_SAM_TYPE_DIGI_PATH = 2, PA_SAM_TYPE_SKEY_K0 = 3, PA_SAM_TYPE_SKEY = 4, PA_SAM_TYPE_SECURID = 5, PA_SAM_TYPE_CRYPTOCARD = 6 } PA_SAM_TYPE; /* PA-SAM-REDIRECT ::= HostAddresses */ typedef HostAddresses PA_SAM_REDIRECT; /* SAMFlags ::= BIT STRING { use-sad-as-key(0), send-encrypted-sad(1), must-pk-encrypt-sad(2) } */ typedef struct SAMFlags { unsigned int use_sad_as_key:1; unsigned int send_encrypted_sad:1; unsigned int must_pk_encrypt_sad:1; unsigned int _unused3:1; unsigned int _unused4:1; unsigned int _unused5:1; unsigned int _unused6:1; unsigned int _unused7:1; unsigned int _unused8:1; unsigned int _unused9:1; unsigned int _unused10:1; unsigned int _unused11:1; unsigned int _unused12:1; unsigned int _unused13:1; unsigned int _unused14:1; unsigned int _unused15:1; unsigned int _unused16:1; unsigned int _unused17:1; unsigned int _unused18:1; unsigned int _unused19:1; unsigned int _unused20:1; unsigned int _unused21:1; unsigned int _unused22:1; unsigned int _unused23:1; unsigned int _unused24:1; unsigned int _unused25:1; unsigned int _unused26:1; unsigned int _unused27:1; unsigned int _unused28:1; unsigned int _unused29:1; unsigned int _unused30:1; unsigned int _unused31:1; } SAMFlags; unsigned SAMFlags2int(SAMFlags); SAMFlags int2SAMFlags(unsigned); const struct units * asn1_SAMFlags_units(void); /* PA-SAM-CHALLENGE-2-BODY ::= SEQUENCE { sam-type [0] krb5int32, sam-flags [1] SAMFlags, sam-type-name [2] GeneralString OPTIONAL, sam-track-id [3] GeneralString OPTIONAL, sam-challenge-label [4] GeneralString OPTIONAL, sam-challenge [5] GeneralString OPTIONAL, sam-response-prompt [6] GeneralString OPTIONAL, sam-pk-for-sad [7] EncryptionKey OPTIONAL, sam-nonce [8] krb5int32, sam-etype [9] krb5int32, ..., } */ typedef struct PA_SAM_CHALLENGE_2_BODY { krb5int32 sam_type; SAMFlags sam_flags; heim_general_string *sam_type_name; heim_general_string *sam_track_id; heim_general_string *sam_challenge_label; heim_general_string *sam_challenge; heim_general_string *sam_response_prompt; EncryptionKey *sam_pk_for_sad; krb5int32 sam_nonce; krb5int32 sam_etype; } PA_SAM_CHALLENGE_2_BODY; /* PA-SAM-CHALLENGE-2 ::= SEQUENCE { sam-body [0] PA-SAM-CHALLENGE-2-BODY, sam-cksum [1] SEQUENCE OF Checksum, ..., } */ typedef struct PA_SAM_CHALLENGE_2 { PA_SAM_CHALLENGE_2_BODY sam_body; struct PA_SAM_CHALLENGE_2_sam_cksum { unsigned int len; Checksum *val; } sam_cksum; } PA_SAM_CHALLENGE_2; /* PA-SAM-RESPONSE-2 ::= SEQUENCE { sam-type [0] krb5int32, sam-flags [1] SAMFlags, sam-track-id [2] GeneralString OPTIONAL, sam-enc-nonce-or-sad [3] EncryptedData, sam-nonce [4] krb5int32, ..., } */ typedef struct PA_SAM_RESPONSE_2 { krb5int32 sam_type; SAMFlags sam_flags; heim_general_string *sam_track_id; EncryptedData sam_enc_nonce_or_sad; krb5int32 sam_nonce; } PA_SAM_RESPONSE_2; /* PA-ENC-SAM-RESPONSE-ENC ::= SEQUENCE { sam-nonce [0] krb5int32, sam-sad [1] GeneralString OPTIONAL, ..., } */ typedef struct PA_ENC_SAM_RESPONSE_ENC { krb5int32 sam_nonce; heim_general_string *sam_sad; } PA_ENC_SAM_RESPONSE_ENC; /* PA-S4U2Self ::= SEQUENCE { name [0] PrincipalName, realm [1] Realm, cksum [2] Checksum, auth [3] GeneralString, } */ typedef struct PA_S4U2Self { PrincipalName name; Realm realm; Checksum cksum; heim_general_string auth; } PA_S4U2Self; ASN1EXP int ASN1CALL decode_PA_S4U2Self(const unsigned char *, size_t, PA_S4U2Self *, size_t *); ASN1EXP int ASN1CALL encode_PA_S4U2Self(unsigned char *, size_t, const PA_S4U2Self *, size_t *); ASN1EXP size_t ASN1CALL length_PA_S4U2Self(const PA_S4U2Self *); ASN1EXP int ASN1CALL copy_PA_S4U2Self (const PA_S4U2Self *, PA_S4U2Self *); ASN1EXP void ASN1CALL free_PA_S4U2Self (PA_S4U2Self *); /* KRB5SignedPathData ::= SEQUENCE { client [0] Principal OPTIONAL, authtime [1] KerberosTime, delegated [2] Principals OPTIONAL, method_data [3] METHOD-DATA OPTIONAL, } */ typedef struct KRB5SignedPathData { Principal *client; KerberosTime authtime; Principals *delegated; METHOD_DATA *method_data; } KRB5SignedPathData; ASN1EXP int ASN1CALL decode_KRB5SignedPathData(const unsigned char *, size_t, KRB5SignedPathData *, size_t *); ASN1EXP int ASN1CALL encode_KRB5SignedPathData(unsigned char *, size_t, const KRB5SignedPathData *, size_t *); ASN1EXP size_t ASN1CALL length_KRB5SignedPathData(const KRB5SignedPathData *); ASN1EXP int ASN1CALL copy_KRB5SignedPathData (const KRB5SignedPathData *, KRB5SignedPathData *); ASN1EXP void ASN1CALL free_KRB5SignedPathData (KRB5SignedPathData *); /* KRB5SignedPath ::= SEQUENCE { etype [0] ENCTYPE, cksum [1] Checksum, delegated [2] Principals OPTIONAL, method_data [3] METHOD-DATA OPTIONAL, } */ typedef struct KRB5SignedPath { ENCTYPE etype; Checksum cksum; Principals *delegated; METHOD_DATA *method_data; } KRB5SignedPath; ASN1EXP int ASN1CALL decode_KRB5SignedPath(const unsigned char *, size_t, KRB5SignedPath *, size_t *); ASN1EXP int ASN1CALL encode_KRB5SignedPath(unsigned char *, size_t, const KRB5SignedPath *, size_t *); ASN1EXP size_t ASN1CALL length_KRB5SignedPath(const KRB5SignedPath *); ASN1EXP int ASN1CALL copy_KRB5SignedPath (const KRB5SignedPath *, KRB5SignedPath *); ASN1EXP void ASN1CALL free_KRB5SignedPath (KRB5SignedPath *); /* AD-LoginAlias ::= SEQUENCE { login-alias [0] PrincipalName, checksum [1] Checksum, } */ typedef struct AD_LoginAlias { PrincipalName login_alias; Checksum checksum; } AD_LoginAlias; ASN1EXP int ASN1CALL decode_AD_LoginAlias(const unsigned char *, size_t, AD_LoginAlias *, size_t *); ASN1EXP int ASN1CALL encode_AD_LoginAlias(unsigned char *, size_t, const AD_LoginAlias *, size_t *); ASN1EXP size_t ASN1CALL length_AD_LoginAlias(const AD_LoginAlias *); ASN1EXP int ASN1CALL copy_AD_LoginAlias (const AD_LoginAlias *, AD_LoginAlias *); ASN1EXP void ASN1CALL free_AD_LoginAlias (AD_LoginAlias *); /* PA-SvrReferralData ::= SEQUENCE { referred-name [1] PrincipalName OPTIONAL, referred-realm [0] Realm, } */ typedef struct PA_SvrReferralData { PrincipalName *referred_name; Realm referred_realm; } PA_SvrReferralData; ASN1EXP int ASN1CALL decode_PA_SvrReferralData(const unsigned char *, size_t, PA_SvrReferralData *, size_t *); ASN1EXP int ASN1CALL encode_PA_SvrReferralData(unsigned char *, size_t, const PA_SvrReferralData *, size_t *); ASN1EXP size_t ASN1CALL length_PA_SvrReferralData(const PA_SvrReferralData *); ASN1EXP int ASN1CALL copy_PA_SvrReferralData (const PA_SvrReferralData *, PA_SvrReferralData *); ASN1EXP void ASN1CALL free_PA_SvrReferralData (PA_SvrReferralData *); /* PA-SERVER-REFERRAL-DATA ::= EncryptedData */ typedef EncryptedData PA_SERVER_REFERRAL_DATA; ASN1EXP int ASN1CALL decode_PA_SERVER_REFERRAL_DATA(const unsigned char *, size_t, PA_SERVER_REFERRAL_DATA *, size_t *); ASN1EXP int ASN1CALL encode_PA_SERVER_REFERRAL_DATA(unsigned char *, size_t, const PA_SERVER_REFERRAL_DATA *, size_t *); ASN1EXP size_t ASN1CALL length_PA_SERVER_REFERRAL_DATA(const PA_SERVER_REFERRAL_DATA *); ASN1EXP int ASN1CALL copy_PA_SERVER_REFERRAL_DATA (const PA_SERVER_REFERRAL_DATA *, PA_SERVER_REFERRAL_DATA *); ASN1EXP void ASN1CALL free_PA_SERVER_REFERRAL_DATA (PA_SERVER_REFERRAL_DATA *); /* PA-ServerReferralData ::= SEQUENCE { referred-realm [0] Realm OPTIONAL, true-principal-name [1] PrincipalName OPTIONAL, requested-principal-name [2] PrincipalName OPTIONAL, referral-valid-until [3] KerberosTime OPTIONAL, ..., } */ typedef struct PA_ServerReferralData { Realm *referred_realm; PrincipalName *true_principal_name; PrincipalName *requested_principal_name; KerberosTime *referral_valid_until; } PA_ServerReferralData; ASN1EXP int ASN1CALL decode_PA_ServerReferralData(const unsigned char *, size_t, PA_ServerReferralData *, size_t *); ASN1EXP int ASN1CALL encode_PA_ServerReferralData(unsigned char *, size_t, const PA_ServerReferralData *, size_t *); ASN1EXP size_t ASN1CALL length_PA_ServerReferralData(const PA_ServerReferralData *); ASN1EXP int ASN1CALL copy_PA_ServerReferralData (const PA_ServerReferralData *, PA_ServerReferralData *); ASN1EXP void ASN1CALL free_PA_ServerReferralData (PA_ServerReferralData *); /* FastOptions ::= BIT STRING { reserved(0), hide-client-names(1), kdc-follow-referrals(16) } */ typedef struct FastOptions { unsigned int reserved:1; unsigned int hide_client_names:1; unsigned int _unused2:1; unsigned int _unused3:1; unsigned int _unused4:1; unsigned int _unused5:1; unsigned int _unused6:1; unsigned int _unused7:1; unsigned int _unused8:1; unsigned int _unused9:1; unsigned int _unused10:1; unsigned int _unused11:1; unsigned int _unused12:1; unsigned int _unused13:1; unsigned int _unused14:1; unsigned int _unused15:1; unsigned int kdc_follow_referrals:1; unsigned int _unused17:1; unsigned int _unused18:1; unsigned int _unused19:1; unsigned int _unused20:1; unsigned int _unused21:1; unsigned int _unused22:1; unsigned int _unused23:1; unsigned int _unused24:1; unsigned int _unused25:1; unsigned int _unused26:1; unsigned int _unused27:1; unsigned int _unused28:1; unsigned int _unused29:1; unsigned int _unused30:1; unsigned int _unused31:1; } FastOptions; unsigned FastOptions2int(FastOptions); FastOptions int2FastOptions(unsigned); const struct units * asn1_FastOptions_units(void); /* KrbFastReq ::= SEQUENCE { fast-options [0] FastOptions, padata [1] METHOD-DATA, req-body [2] KDC-REQ-BODY, ..., } */ typedef struct KrbFastReq { FastOptions fast_options; METHOD_DATA padata; KDC_REQ_BODY req_body; } KrbFastReq; ASN1EXP int ASN1CALL decode_KrbFastReq(const unsigned char *, size_t, KrbFastReq *, size_t *); ASN1EXP int ASN1CALL encode_KrbFastReq(unsigned char *, size_t, const KrbFastReq *, size_t *); ASN1EXP size_t ASN1CALL length_KrbFastReq(const KrbFastReq *); ASN1EXP int ASN1CALL copy_KrbFastReq (const KrbFastReq *, KrbFastReq *); ASN1EXP void ASN1CALL free_KrbFastReq (KrbFastReq *); /* KrbFastArmor ::= SEQUENCE { armor-type [0] krb5int32, armor-value [1] OCTET STRING, ..., } */ typedef struct KrbFastArmor { krb5int32 armor_type; heim_octet_string armor_value; } KrbFastArmor; ASN1EXP int ASN1CALL decode_KrbFastArmor(const unsigned char *, size_t, KrbFastArmor *, size_t *); ASN1EXP int ASN1CALL encode_KrbFastArmor(unsigned char *, size_t, const KrbFastArmor *, size_t *); ASN1EXP size_t ASN1CALL length_KrbFastArmor(const KrbFastArmor *); ASN1EXP int ASN1CALL copy_KrbFastArmor (const KrbFastArmor *, KrbFastArmor *); ASN1EXP void ASN1CALL free_KrbFastArmor (KrbFastArmor *); /* KrbFastArmoredReq ::= SEQUENCE { armor [0] KrbFastArmor OPTIONAL, req-checksum [1] Checksum, enc-fast-req [2] EncryptedData, } */ typedef struct KrbFastArmoredReq { KrbFastArmor *armor; Checksum req_checksum; EncryptedData enc_fast_req; } KrbFastArmoredReq; /* PA-FX-FAST-REQUEST ::= CHOICE { armored-data [0] KrbFastArmoredReq, ..., } */ typedef struct PA_FX_FAST_REQUEST { enum PA_FX_FAST_REQUEST_enum { choice_PA_FX_FAST_REQUEST_asn1_ellipsis = 0, choice_PA_FX_FAST_REQUEST_armored_data /* ... */ } element; union { KrbFastArmoredReq armored_data; heim_octet_string asn1_ellipsis; } u; } PA_FX_FAST_REQUEST; ASN1EXP int ASN1CALL decode_PA_FX_FAST_REQUEST(const unsigned char *, size_t, PA_FX_FAST_REQUEST *, size_t *); ASN1EXP int ASN1CALL encode_PA_FX_FAST_REQUEST(unsigned char *, size_t, const PA_FX_FAST_REQUEST *, size_t *); ASN1EXP size_t ASN1CALL length_PA_FX_FAST_REQUEST(const PA_FX_FAST_REQUEST *); ASN1EXP int ASN1CALL copy_PA_FX_FAST_REQUEST (const PA_FX_FAST_REQUEST *, PA_FX_FAST_REQUEST *); ASN1EXP void ASN1CALL free_PA_FX_FAST_REQUEST (PA_FX_FAST_REQUEST *); /* KrbFastFinished ::= SEQUENCE { timestamp [0] KerberosTime, usec [1] krb5int32, crealm [2] Realm, cname [3] PrincipalName, ticket-checksum [4] Checksum, ..., } */ typedef struct KrbFastFinished { KerberosTime timestamp; krb5int32 usec; Realm crealm; PrincipalName cname; Checksum ticket_checksum; } KrbFastFinished; ASN1EXP int ASN1CALL decode_KrbFastFinished(const unsigned char *, size_t, KrbFastFinished *, size_t *); ASN1EXP int ASN1CALL encode_KrbFastFinished(unsigned char *, size_t, const KrbFastFinished *, size_t *); ASN1EXP size_t ASN1CALL length_KrbFastFinished(const KrbFastFinished *); ASN1EXP int ASN1CALL copy_KrbFastFinished (const KrbFastFinished *, KrbFastFinished *); ASN1EXP void ASN1CALL free_KrbFastFinished (KrbFastFinished *); /* KrbFastResponse ::= SEQUENCE { padata [0] METHOD-DATA, strengthen-key [1] EncryptionKey OPTIONAL, finished [2] KrbFastFinished OPTIONAL, nonce [3] krb5uint32, ..., } */ typedef struct KrbFastResponse { METHOD_DATA padata; EncryptionKey *strengthen_key; KrbFastFinished *finished; krb5uint32 nonce; } KrbFastResponse; ASN1EXP int ASN1CALL decode_KrbFastResponse(const unsigned char *, size_t, KrbFastResponse *, size_t *); ASN1EXP int ASN1CALL encode_KrbFastResponse(unsigned char *, size_t, const KrbFastResponse *, size_t *); ASN1EXP size_t ASN1CALL length_KrbFastResponse(const KrbFastResponse *); ASN1EXP int ASN1CALL copy_KrbFastResponse (const KrbFastResponse *, KrbFastResponse *); ASN1EXP void ASN1CALL free_KrbFastResponse (KrbFastResponse *); /* KrbFastArmoredRep ::= SEQUENCE { enc-fast-rep [0] EncryptedData, ..., } */ typedef struct KrbFastArmoredRep { EncryptedData enc_fast_rep; } KrbFastArmoredRep; /* PA-FX-FAST-REPLY ::= CHOICE { armored-data [0] KrbFastArmoredRep, ..., } */ typedef struct PA_FX_FAST_REPLY { enum PA_FX_FAST_REPLY_enum { choice_PA_FX_FAST_REPLY_asn1_ellipsis = 0, choice_PA_FX_FAST_REPLY_armored_data /* ... */ } element; union { KrbFastArmoredRep armored_data; heim_octet_string asn1_ellipsis; } u; } PA_FX_FAST_REPLY; ASN1EXP int ASN1CALL decode_PA_FX_FAST_REPLY(const unsigned char *, size_t, PA_FX_FAST_REPLY *, size_t *); ASN1EXP int ASN1CALL encode_PA_FX_FAST_REPLY(unsigned char *, size_t, const PA_FX_FAST_REPLY *, size_t *); ASN1EXP size_t ASN1CALL length_PA_FX_FAST_REPLY(const PA_FX_FAST_REPLY *); ASN1EXP int ASN1CALL copy_PA_FX_FAST_REPLY (const PA_FX_FAST_REPLY *, PA_FX_FAST_REPLY *); ASN1EXP void ASN1CALL free_PA_FX_FAST_REPLY (PA_FX_FAST_REPLY *); /* KDCFastFlags ::= BIT STRING { use_reply_key(0), reply_key_used(1), reply_key_replaced(2), kdc_verfied(3) } */ typedef struct KDCFastFlags { unsigned int use_reply_key:1; unsigned int reply_key_used:1; unsigned int reply_key_replaced:1; unsigned int kdc_verfied:1; unsigned int _unused4:1; unsigned int _unused5:1; unsigned int _unused6:1; unsigned int _unused7:1; unsigned int _unused8:1; unsigned int _unused9:1; unsigned int _unused10:1; unsigned int _unused11:1; unsigned int _unused12:1; unsigned int _unused13:1; unsigned int _unused14:1; unsigned int _unused15:1; unsigned int _unused16:1; unsigned int _unused17:1; unsigned int _unused18:1; unsigned int _unused19:1; unsigned int _unused20:1; unsigned int _unused21:1; unsigned int _unused22:1; unsigned int _unused23:1; unsigned int _unused24:1; unsigned int _unused25:1; unsigned int _unused26:1; unsigned int _unused27:1; unsigned int _unused28:1; unsigned int _unused29:1; unsigned int _unused30:1; unsigned int _unused31:1; } KDCFastFlags; unsigned KDCFastFlags2int(KDCFastFlags); KDCFastFlags int2KDCFastFlags(unsigned); const struct units * asn1_KDCFastFlags_units(void); /* KDCFastState ::= SEQUENCE { flags [0] KDCFastFlags, expiration [1] GeneralizedTime, fast-state [2] METHOD-DATA, expected-pa-types [3] SEQUENCE OF PADATA-TYPE OPTIONAL, } */ typedef struct KDCFastState { KDCFastFlags flags; time_t expiration; METHOD_DATA fast_state; struct KDCFastState_expected_pa_types { unsigned int len; PADATA_TYPE *val; } *expected_pa_types; } KDCFastState; ASN1EXP int ASN1CALL decode_KDCFastState(const unsigned char *, size_t, KDCFastState *, size_t *); ASN1EXP int ASN1CALL encode_KDCFastState(unsigned char *, size_t, const KDCFastState *, size_t *); ASN1EXP size_t ASN1CALL length_KDCFastState(const KDCFastState *); ASN1EXP int ASN1CALL copy_KDCFastState (const KDCFastState *, KDCFastState *); ASN1EXP void ASN1CALL free_KDCFastState (KDCFastState *); /* KDCFastCookie ::= SEQUENCE { version [0] UTF8String, cookie [1] EncryptedData, } */ typedef struct KDCFastCookie { heim_utf8_string version; EncryptedData cookie; } KDCFastCookie; ASN1EXP int ASN1CALL decode_KDCFastCookie(const unsigned char *, size_t, KDCFastCookie *, size_t *); ASN1EXP int ASN1CALL encode_KDCFastCookie(unsigned char *, size_t, const KDCFastCookie *, size_t *); ASN1EXP size_t ASN1CALL length_KDCFastCookie(const KDCFastCookie *); ASN1EXP int ASN1CALL copy_KDCFastCookie (const KDCFastCookie *, KDCFastCookie *); ASN1EXP void ASN1CALL free_KDCFastCookie (KDCFastCookie *); /* KDC-PROXY-MESSAGE ::= SEQUENCE { kerb-message [0] OCTET STRING, target-domain [1] Realm OPTIONAL, dclocator-hint [2] INTEGER OPTIONAL, } */ typedef struct KDC_PROXY_MESSAGE { heim_octet_string kerb_message; Realm *target_domain; heim_integer *dclocator_hint; } KDC_PROXY_MESSAGE; ASN1EXP int ASN1CALL decode_KDC_PROXY_MESSAGE(const unsigned char *, size_t, KDC_PROXY_MESSAGE *, size_t *); ASN1EXP int ASN1CALL encode_KDC_PROXY_MESSAGE(unsigned char *, size_t, const KDC_PROXY_MESSAGE *, size_t *); ASN1EXP size_t ASN1CALL length_KDC_PROXY_MESSAGE(const KDC_PROXY_MESSAGE *); ASN1EXP int ASN1CALL copy_KDC_PROXY_MESSAGE (const KDC_PROXY_MESSAGE *, KDC_PROXY_MESSAGE *); ASN1EXP void ASN1CALL free_KDC_PROXY_MESSAGE (KDC_PROXY_MESSAGE *); /* KERB-TIMES ::= SEQUENCE { authtime [0] KerberosTime, starttime [1] KerberosTime, endtime [2] KerberosTime, renew_till [3] KerberosTime, } */ typedef struct KERB_TIMES { KerberosTime authtime; KerberosTime starttime; KerberosTime endtime; KerberosTime renew_till; } KERB_TIMES; ASN1EXP int ASN1CALL decode_KERB_TIMES(const unsigned char *, size_t, KERB_TIMES *, size_t *); ASN1EXP int ASN1CALL encode_KERB_TIMES(unsigned char *, size_t, const KERB_TIMES *, size_t *); ASN1EXP size_t ASN1CALL length_KERB_TIMES(const KERB_TIMES *); ASN1EXP int ASN1CALL copy_KERB_TIMES (const KERB_TIMES *, KERB_TIMES *); ASN1EXP void ASN1CALL free_KERB_TIMES (KERB_TIMES *); /* KERB-CRED ::= SEQUENCE { client [0] Principal, server [1] Principal, keyblock [2] EncryptionKey, times [3] KERB-TIMES, ticket [4] OCTET STRING, authdata [5] OCTET STRING, addresses [6] HostAddresses, flags [7] TicketFlags, } */ typedef struct KERB_CRED { Principal client; Principal server; EncryptionKey keyblock; KERB_TIMES times; heim_octet_string ticket; heim_octet_string authdata; HostAddresses addresses; TicketFlags flags; } KERB_CRED; ASN1EXP int ASN1CALL decode_KERB_CRED(const unsigned char *, size_t, KERB_CRED *, size_t *); ASN1EXP int ASN1CALL encode_KERB_CRED(unsigned char *, size_t, const KERB_CRED *, size_t *); ASN1EXP size_t ASN1CALL length_KERB_CRED(const KERB_CRED *); ASN1EXP int ASN1CALL copy_KERB_CRED (const KERB_CRED *, KERB_CRED *); ASN1EXP void ASN1CALL free_KERB_CRED (KERB_CRED *); /* KERB-TGS-REQ-IN ::= SEQUENCE { cache [0] OCTET STRING, addrs [1] HostAddresses, flags [2] krb5uint32, imp [3] Principal OPTIONAL, ticket [4] OCTET STRING OPTIONAL, in_cred [5] KERB-CRED, krbtgt [6] KERB-CRED, padata [7] METHOD-DATA, } */ typedef struct KERB_TGS_REQ_IN { heim_octet_string cache; HostAddresses addrs; krb5uint32 flags; Principal *imp; heim_octet_string *ticket; KERB_CRED in_cred; KERB_CRED krbtgt; METHOD_DATA padata; } KERB_TGS_REQ_IN; ASN1EXP int ASN1CALL decode_KERB_TGS_REQ_IN(const unsigned char *, size_t, KERB_TGS_REQ_IN *, size_t *); ASN1EXP int ASN1CALL encode_KERB_TGS_REQ_IN(unsigned char *, size_t, const KERB_TGS_REQ_IN *, size_t *); ASN1EXP size_t ASN1CALL length_KERB_TGS_REQ_IN(const KERB_TGS_REQ_IN *); ASN1EXP int ASN1CALL copy_KERB_TGS_REQ_IN (const KERB_TGS_REQ_IN *, KERB_TGS_REQ_IN *); ASN1EXP void ASN1CALL free_KERB_TGS_REQ_IN (KERB_TGS_REQ_IN *); /* KERB-TGS-REQ-OUT ::= SEQUENCE { subkey [0] EncryptionKey OPTIONAL, t [1] TGS-REQ, } */ typedef struct KERB_TGS_REQ_OUT { EncryptionKey *subkey; TGS_REQ t; } KERB_TGS_REQ_OUT; ASN1EXP int ASN1CALL decode_KERB_TGS_REQ_OUT(const unsigned char *, size_t, KERB_TGS_REQ_OUT *, size_t *); ASN1EXP int ASN1CALL encode_KERB_TGS_REQ_OUT(unsigned char *, size_t, const KERB_TGS_REQ_OUT *, size_t *); ASN1EXP size_t ASN1CALL length_KERB_TGS_REQ_OUT(const KERB_TGS_REQ_OUT *); ASN1EXP int ASN1CALL copy_KERB_TGS_REQ_OUT (const KERB_TGS_REQ_OUT *, KERB_TGS_REQ_OUT *); ASN1EXP void ASN1CALL free_KERB_TGS_REQ_OUT (KERB_TGS_REQ_OUT *); /* KERB-TGS-REP-IN ::= SEQUENCE { cache [0] OCTET STRING, subkey [1] EncryptionKey OPTIONAL, in_cred [2] KERB-CRED, t [3] TGS-REP, } */ typedef struct KERB_TGS_REP_IN { heim_octet_string cache; EncryptionKey *subkey; KERB_CRED in_cred; TGS_REP t; } KERB_TGS_REP_IN; /* KERB-TGS-REP-OUT ::= SEQUENCE { cache [0] OCTET STRING, cred [1] KERB-CRED, subkey [2] EncryptionKey, } */ typedef struct KERB_TGS_REP_OUT { heim_octet_string cache; KERB_CRED cred; EncryptionKey subkey; } KERB_TGS_REP_OUT; /* KERB-ARMOR-SERVICE-REPLY ::= SEQUENCE { armor [0] KrbFastArmor, armor-key [1] EncryptionKey, } */ typedef struct KERB_ARMOR_SERVICE_REPLY { KrbFastArmor armor; EncryptionKey armor_key; } KERB_ARMOR_SERVICE_REPLY; ASN1EXP int ASN1CALL decode_KERB_ARMOR_SERVICE_REPLY(const unsigned char *, size_t, KERB_ARMOR_SERVICE_REPLY *, size_t *); ASN1EXP int ASN1CALL encode_KERB_ARMOR_SERVICE_REPLY(unsigned char *, size_t, const KERB_ARMOR_SERVICE_REPLY *, size_t *); ASN1EXP size_t ASN1CALL length_KERB_ARMOR_SERVICE_REPLY(const KERB_ARMOR_SERVICE_REPLY *); ASN1EXP int ASN1CALL copy_KERB_ARMOR_SERVICE_REPLY (const KERB_ARMOR_SERVICE_REPLY *, KERB_ARMOR_SERVICE_REPLY *); ASN1EXP void ASN1CALL free_KERB_ARMOR_SERVICE_REPLY (KERB_ARMOR_SERVICE_REPLY *); #endif /* __krb5_asn1_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/krb5_ccapi.h000066400000000000000000000170231505521762700227720ustar00rootroot00000000000000/* * Copyright (c) 2004 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef KRB5_CCAPI_H #define KRB5_CCAPI_H 1 #include #ifdef __APPLE__ #pragma pack(push,2) #endif enum { cc_credentials_v5 = 2 }; enum { ccapi_version_3 = 3, ccapi_version_4 = 4 }; enum { ccNoError = 0, ccIteratorEnd = 201, ccErrBadParam, ccErrNoMem, ccErrInvalidContext, ccErrInvalidCCache, ccErrInvalidString, /* 206 */ ccErrInvalidCredentials, ccErrInvalidCCacheIterator, ccErrInvalidCredentialsIterator, ccErrInvalidLock, ccErrBadName, /* 211 */ ccErrBadCredentialsVersion, ccErrBadAPIVersion, ccErrContextLocked, ccErrContextUnlocked, ccErrCCacheLocked, /* 216 */ ccErrCCacheUnlocked, ccErrBadLockType, ccErrNeverDefault, ccErrCredentialsNotFound, ccErrCCacheNotFound, /* 221 */ ccErrContextNotFound, ccErrServerUnavailable, ccErrServerInsecure, ccErrServerCantBecomeUID, ccErrTimeOffsetNotSet /* 226 */ }; typedef int32_t cc_int32; typedef uint32_t cc_uint32; typedef struct cc_context_t *cc_context_t; typedef struct cc_ccache_t *cc_ccache_t; typedef struct cc_ccache_iterator_t *cc_ccache_iterator_t; typedef struct cc_credentials_v5_t cc_credentials_v5_t; typedef struct cc_credentials_t *cc_credentials_t; typedef struct cc_credentials_iterator_t *cc_credentials_iterator_t; typedef struct cc_string_t *cc_string_t; typedef cc_uint32 cc_time_t; typedef struct cc_data { cc_uint32 type; cc_uint32 length; void *data; } cc_data; struct cc_credentials_v5_t { char *client; char *server; cc_data keyblock; cc_time_t authtime; cc_time_t starttime; cc_time_t endtime; cc_time_t renew_till; cc_uint32 is_skey; cc_uint32 ticket_flags; #define KRB5_CCAPI_TKT_FLG_FORWARDABLE 0x40000000 #define KRB5_CCAPI_TKT_FLG_FORWARDED 0x20000000 #define KRB5_CCAPI_TKT_FLG_PROXIABLE 0x10000000 #define KRB5_CCAPI_TKT_FLG_PROXY 0x08000000 #define KRB5_CCAPI_TKT_FLG_MAY_POSTDATE 0x04000000 #define KRB5_CCAPI_TKT_FLG_POSTDATED 0x02000000 #define KRB5_CCAPI_TKT_FLG_INVALID 0x01000000 #define KRB5_CCAPI_TKT_FLG_RENEWABLE 0x00800000 #define KRB5_CCAPI_TKT_FLG_INITIAL 0x00400000 #define KRB5_CCAPI_TKT_FLG_PRE_AUTH 0x00200000 #define KRB5_CCAPI_TKT_FLG_HW_AUTH 0x00100000 #define KRB5_CCAPI_TKT_FLG_TRANSIT_POLICY_CHECKED 0x00080000 #define KRB5_CCAPI_TKT_FLG_OK_AS_DELEGATE 0x00040000 #define KRB5_CCAPI_TKT_FLG_ANONYMOUS 0x00020000 cc_data **addresses; cc_data ticket; cc_data second_ticket; cc_data **authdata; }; typedef struct cc_string_functions { cc_int32 (*release)(cc_string_t); } cc_string_functions; struct cc_string_t { const char *data; const cc_string_functions *func; }; typedef struct cc_credentials_union { cc_int32 version; union { cc_credentials_v5_t* credentials_v5; } credentials; } cc_credentials_union; struct cc_credentials_functions { cc_int32 (*release)(cc_credentials_t); cc_int32 (*compare)(cc_credentials_t, cc_credentials_t, cc_uint32*); }; struct cc_credentials_t { const cc_credentials_union* data; const struct cc_credentials_functions* func; }; struct cc_credentials_iterator_functions { cc_int32 (*release)(cc_credentials_iterator_t); cc_int32 (*next)(cc_credentials_iterator_t, cc_credentials_t*); }; struct cc_credentials_iterator_t { const struct cc_credentials_iterator_functions *func; }; struct cc_ccache_iterator_functions { cc_int32 (*release) (cc_ccache_iterator_t); cc_int32 (*next)(cc_ccache_iterator_t, cc_ccache_t*); }; struct cc_ccache_iterator_t { const struct cc_ccache_iterator_functions* func; }; typedef struct cc_ccache_functions { cc_int32 (*release)(cc_ccache_t); cc_int32 (*destroy)(cc_ccache_t); cc_int32 (*set_default)(cc_ccache_t); cc_int32 (*get_credentials_version)(cc_ccache_t, cc_uint32*); cc_int32 (*get_name)(cc_ccache_t, cc_string_t*); cc_int32 (*get_principal)(cc_ccache_t, cc_uint32, cc_string_t*); cc_int32 (*set_principal)(cc_ccache_t, cc_uint32, const char*); cc_int32 (*store_credentials)(cc_ccache_t, const cc_credentials_union*); cc_int32 (*remove_credentials)(cc_ccache_t, cc_credentials_t); cc_int32 (*new_credentials_iterator)(cc_ccache_t, cc_credentials_iterator_t*); cc_int32 (*move)(cc_ccache_t, cc_ccache_t); cc_int32 (*lock)(cc_ccache_t, cc_uint32, cc_uint32); cc_int32 (*unlock)(cc_ccache_t); cc_int32 (*get_last_default_time)(cc_ccache_t, cc_time_t*); cc_int32 (*get_change_time)(cc_ccache_t, cc_time_t*); cc_int32 (*compare)(cc_ccache_t, cc_ccache_t, cc_uint32*); cc_int32 (*get_kdc_time_offset)(cc_ccache_t, cc_int32, cc_time_t *); cc_int32 (*set_kdc_time_offset)(cc_ccache_t, cc_int32, cc_time_t); cc_int32 (*clear_kdc_time_offset)(cc_ccache_t, cc_int32); } cc_ccache_functions; struct cc_ccache_t { const cc_ccache_functions *func; }; struct cc_context_functions { cc_int32 (*release)(cc_context_t); cc_int32 (*get_change_time)(cc_context_t, cc_time_t *); cc_int32 (*get_default_ccache_name)(cc_context_t, cc_string_t*); cc_int32 (*open_ccache)(cc_context_t, const char*, cc_ccache_t *); cc_int32 (*open_default_ccache)(cc_context_t, cc_ccache_t*); cc_int32 (*create_ccache)(cc_context_t,const char*, cc_uint32, const char*, cc_ccache_t*); cc_int32 (*create_default_ccache)(cc_context_t, cc_uint32, const char*, cc_ccache_t*); cc_int32 (*create_new_ccache)(cc_context_t, cc_uint32, const char*, cc_ccache_t*); cc_int32 (*new_ccache_iterator)(cc_context_t, cc_ccache_iterator_t*); cc_int32 (*lock)(cc_context_t, cc_uint32, cc_uint32); cc_int32 (*unlock)(cc_context_t); cc_int32 (*compare)(cc_context_t, cc_context_t, cc_uint32*); }; struct cc_context_t { const struct cc_context_functions* func; }; typedef cc_int32 (*cc_initialize_func)(cc_context_t*, cc_int32, cc_int32 *, char const **); #ifdef __APPLE__ #pragma pack(pop) #endif #endif /* KRB5_CCAPI_H */ pykrb5-0.8.0/build_helpers/heimdal/include/krb5_err.h000066400000000000000000000166141505521762700225100ustar00rootroot00000000000000/* Generated from krb5_err.et */ /* $Id$ */ #ifndef __krb5_err_h__ #define __krb5_err_h__ struct et_list; void initialize_krb5_error_table_r(struct et_list **); void initialize_krb5_error_table(void); #define init_krb5_err_tbl initialize_krb5_error_table typedef enum krb5_error_number{ KRB5KDC_ERR_NONE = -1765328384, KRB5KDC_ERR_NAME_EXP = -1765328383, KRB5KDC_ERR_SERVICE_EXP = -1765328382, KRB5KDC_ERR_BAD_PVNO = -1765328381, KRB5KDC_ERR_C_OLD_MAST_KVNO = -1765328380, KRB5KDC_ERR_S_OLD_MAST_KVNO = -1765328379, KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN = -1765328378, KRB5KDC_ERR_S_PRINCIPAL_UNKNOWN = -1765328377, KRB5KDC_ERR_PRINCIPAL_NOT_UNIQUE = -1765328376, KRB5KDC_ERR_NULL_KEY = -1765328375, KRB5KDC_ERR_CANNOT_POSTDATE = -1765328374, KRB5KDC_ERR_NEVER_VALID = -1765328373, KRB5KDC_ERR_POLICY = -1765328372, KRB5KDC_ERR_BADOPTION = -1765328371, KRB5KDC_ERR_ETYPE_NOSUPP = -1765328370, KRB5KDC_ERR_SUMTYPE_NOSUPP = -1765328369, KRB5KDC_ERR_PADATA_TYPE_NOSUPP = -1765328368, KRB5KDC_ERR_TRTYPE_NOSUPP = -1765328367, KRB5KDC_ERR_CLIENT_REVOKED = -1765328366, KRB5KDC_ERR_SERVICE_REVOKED = -1765328365, KRB5KDC_ERR_TGT_REVOKED = -1765328364, KRB5KDC_ERR_CLIENT_NOTYET = -1765328363, KRB5KDC_ERR_SERVICE_NOTYET = -1765328362, KRB5KDC_ERR_KEY_EXPIRED = -1765328361, KRB5KDC_ERR_PREAUTH_FAILED = -1765328360, KRB5KDC_ERR_PREAUTH_REQUIRED = -1765328359, KRB5KDC_ERR_SERVER_NOMATCH = -1765328358, KRB5KDC_ERR_KDC_ERR_MUST_USE_USER2USER = -1765328357, KRB5KDC_ERR_PATH_NOT_ACCEPTED = -1765328356, KRB5KDC_ERR_SVC_UNAVAILABLE = -1765328355, KRB5KRB_AP_ERR_BAD_INTEGRITY = -1765328353, KRB5KRB_AP_ERR_TKT_EXPIRED = -1765328352, KRB5KRB_AP_ERR_TKT_NYV = -1765328351, KRB5KRB_AP_ERR_REPEAT = -1765328350, KRB5KRB_AP_ERR_NOT_US = -1765328349, KRB5KRB_AP_ERR_BADMATCH = -1765328348, KRB5KRB_AP_ERR_SKEW = -1765328347, KRB5KRB_AP_ERR_BADADDR = -1765328346, KRB5KRB_AP_ERR_BADVERSION = -1765328345, KRB5KRB_AP_ERR_MSG_TYPE = -1765328344, KRB5KRB_AP_ERR_MODIFIED = -1765328343, KRB5KRB_AP_ERR_BADORDER = -1765328342, KRB5KRB_AP_ERR_ILL_CR_TKT = -1765328341, KRB5KRB_AP_ERR_BADKEYVER = -1765328340, KRB5KRB_AP_ERR_NOKEY = -1765328339, KRB5KRB_AP_ERR_MUT_FAIL = -1765328338, KRB5KRB_AP_ERR_BADDIRECTION = -1765328337, KRB5KRB_AP_ERR_METHOD = -1765328336, KRB5KRB_AP_ERR_BADSEQ = -1765328335, KRB5KRB_AP_ERR_INAPP_CKSUM = -1765328334, KRB5KRB_AP_PATH_NOT_ACCEPTED = -1765328333, KRB5KRB_ERR_RESPONSE_TOO_BIG = -1765328332, KRB5KRB_ERR_GENERIC = -1765328324, KRB5KRB_ERR_FIELD_TOOLONG = -1765328323, KRB5_KDC_ERR_CLIENT_NOT_TRUSTED = -1765328322, KRB5_KDC_ERR_KDC_NOT_TRUSTED = -1765328321, KRB5_KDC_ERR_INVALID_SIG = -1765328320, KRB5_KDC_ERR_DH_KEY_PARAMETERS_NOT_ACCEPTED = -1765328319, KRB5_KDC_ERR_WRONG_REALM = -1765328316, KRB5_AP_ERR_USER_TO_USER_REQUIRED = -1765328315, KRB5_KDC_ERR_CANT_VERIFY_CERTIFICATE = -1765328314, KRB5_KDC_ERR_INVALID_CERTIFICATE = -1765328313, KRB5_KDC_ERR_REVOKED_CERTIFICATE = -1765328312, KRB5_KDC_ERR_REVOCATION_STATUS_UNKNOWN = -1765328311, KRB5_KDC_ERR_REVOCATION_STATUS_UNAVAILABLE = -1765328310, KRB5_KDC_ERR_CLIENT_NAME_MISMATCH = -1765328309, KRB5_KDC_ERR_INCONSISTENT_KEY_PURPOSE = -1765328308, KRB5_KDC_ERR_DIGEST_IN_CERT_NOT_ACCEPTED = -1765328307, KRB5_KDC_ERR_PA_CHECKSUM_MUST_BE_INCLUDED = -1765328306, KRB5_KDC_ERR_DIGEST_IN_SIGNED_DATA_NOT_ACCEPTED = -1765328305, KRB5_KDC_ERR_PUBLIC_KEY_ENCRYPTION_NOT_SUPPORTED = -1765328304, KRB5_KDC_ERR_INVALID_HASH_ALG = -1765328290, KRB5_KDC_ERR_INVALID_ITERATION_COUNT = -1765328289, KRB5_KDC_ERR_NO_ACCEPTABLE_KDF = -1765328284, KRB5_ERR_RCSID = -1765328256, KRB5_LIBOS_BADLOCKFLAG = -1765328255, KRB5_LIBOS_CANTREADPWD = -1765328254, KRB5_LIBOS_BADPWDMATCH = -1765328253, KRB5_LIBOS_PWDINTR = -1765328252, KRB5_PARSE_ILLCHAR = -1765328251, KRB5_PARSE_MALFORMED = -1765328250, KRB5_CONFIG_CANTOPEN = -1765328249, KRB5_CONFIG_BADFORMAT = -1765328248, KRB5_CONFIG_NOTENUFSPACE = -1765328247, KRB5_BADMSGTYPE = -1765328246, KRB5_CC_BADNAME = -1765328245, KRB5_CC_UNKNOWN_TYPE = -1765328244, KRB5_CC_NOTFOUND = -1765328243, KRB5_CC_END = -1765328242, KRB5_NO_TKT_SUPPLIED = -1765328241, KRB5KRB_AP_WRONG_PRINC = -1765328240, KRB5KRB_AP_ERR_TKT_INVALID = -1765328239, KRB5_PRINC_NOMATCH = -1765328238, KRB5_KDCREP_MODIFIED = -1765328237, KRB5_KDCREP_SKEW = -1765328236, KRB5_IN_TKT_REALM_MISMATCH = -1765328235, KRB5_PROG_ETYPE_NOSUPP = -1765328234, KRB5_PROG_KEYTYPE_NOSUPP = -1765328233, KRB5_WRONG_ETYPE = -1765328232, KRB5_PROG_SUMTYPE_NOSUPP = -1765328231, KRB5_REALM_UNKNOWN = -1765328230, KRB5_SERVICE_UNKNOWN = -1765328229, KRB5_KDC_UNREACH = -1765328228, KRB5_NO_LOCALNAME = -1765328227, KRB5_MUTUAL_FAILED = -1765328226, KRB5_RC_TYPE_EXISTS = -1765328225, KRB5_RC_MALLOC = -1765328224, KRB5_RC_TYPE_NOTFOUND = -1765328223, KRB5_RC_UNKNOWN = -1765328222, KRB5_RC_REPLAY = -1765328221, KRB5_RC_IO = -1765328220, KRB5_RC_NOIO = -1765328219, KRB5_RC_PARSE = -1765328218, KRB5_RC_IO_EOF = -1765328217, KRB5_RC_IO_MALLOC = -1765328216, KRB5_RC_IO_PERM = -1765328215, KRB5_RC_IO_IO = -1765328214, KRB5_RC_IO_UNKNOWN = -1765328213, KRB5_RC_IO_SPACE = -1765328212, KRB5_TRANS_CANTOPEN = -1765328211, KRB5_TRANS_BADFORMAT = -1765328210, KRB5_LNAME_CANTOPEN = -1765328209, KRB5_LNAME_NOTRANS = -1765328208, KRB5_LNAME_BADFORMAT = -1765328207, KRB5_CRYPTO_INTERNAL = -1765328206, KRB5_KT_BADNAME = -1765328205, KRB5_KT_UNKNOWN_TYPE = -1765328204, KRB5_KT_NOTFOUND = -1765328203, KRB5_KT_END = -1765328202, KRB5_KT_NOWRITE = -1765328201, KRB5_KT_IOERR = -1765328200, KRB5_NO_TKT_IN_RLM = -1765328199, KRB5DES_BAD_KEYPAR = -1765328198, KRB5DES_WEAK_KEY = -1765328197, KRB5_BAD_ENCTYPE = -1765328196, KRB5_BAD_KEYSIZE = -1765328195, KRB5_BAD_MSIZE = -1765328194, KRB5_CC_TYPE_EXISTS = -1765328193, KRB5_KT_TYPE_EXISTS = -1765328192, KRB5_CC_IO = -1765328191, KRB5_FCC_PERM = -1765328190, KRB5_FCC_NOFILE = -1765328189, KRB5_FCC_INTERNAL = -1765328188, KRB5_CC_WRITE = -1765328187, KRB5_CC_NOMEM = -1765328186, KRB5_CC_FORMAT = -1765328185, KRB5_CC_NOT_KTYPE = -1765328184, KRB5_INVALID_FLAGS = -1765328183, KRB5_NO_2ND_TKT = -1765328182, KRB5_NOCREDS_SUPPLIED = -1765328181, KRB5_SENDAUTH_BADAUTHVERS = -1765328180, KRB5_SENDAUTH_BADAPPLVERS = -1765328179, KRB5_SENDAUTH_BADRESPONSE = -1765328178, KRB5_SENDAUTH_REJECTED = -1765328177, KRB5_PREAUTH_BAD_TYPE = -1765328176, KRB5_PREAUTH_NO_KEY = -1765328175, KRB5_PREAUTH_FAILED = -1765328174, KRB5_RCACHE_BADVNO = -1765328173, KRB5_CCACHE_BADVNO = -1765328172, KRB5_KEYTAB_BADVNO = -1765328171, KRB5_PROG_ATYPE_NOSUPP = -1765328170, KRB5_RC_REQUIRED = -1765328169, KRB5_ERR_BAD_HOSTNAME = -1765328168, KRB5_ERR_HOST_REALM_UNKNOWN = -1765328167, KRB5_SNAME_UNSUPP_NAMETYPE = -1765328166, KRB5KRB_AP_ERR_V4_REPLY = -1765328165, KRB5_REALM_CANT_RESOLVE = -1765328164, KRB5_TKT_NOT_FORWARDABLE = -1765328163, KRB5_FWD_BAD_PRINCIPAL = -1765328162, KRB5_GET_IN_TKT_LOOP = -1765328161, KRB5_CONFIG_NODEFREALM = -1765328160, KRB5_SAM_UNSUPPORTED = -1765328159, KRB5_SAM_INVALID_ETYPE = -1765328158, KRB5_SAM_NO_CHECKSUM = -1765328157, KRB5_SAM_BAD_CHECKSUM = -1765328156, KRB5_OBSOLETE_FN = -1765328146, KRB5_ERR_BAD_S2K_PARAMS = -1765328139, KRB5_ERR_NO_SERVICE = -1765328138, KRB5_CC_NOSUPP = -1765328137, KRB5_DELTAT_BADFORMAT = -1765328136, KRB5_PLUGIN_NO_HANDLE = -1765328135, KRB5_PLUGIN_OP_NOTSUPP = -1765328134 } krb5_error_number; #define ERROR_TABLE_BASE_krb5 -1765328384 #define COM_ERR_BINDDOMAIN_krb5 "heim_com_err-1765328384" #endif /* __krb5_err_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/kx509_asn1.h000066400000000000000000000112411505521762700225660ustar00rootroot00000000000000/* Generated from ./kx509.asn1 */ /* Do not edit */ #ifndef __kx509_asn1_h__ #define __kx509_asn1_h__ #include #include #ifndef __asn1_common_definitions__ #define __asn1_common_definitions__ #ifndef __HEIM_BASE_DATA__ #define __HEIM_BASE_DATA__ 1 struct heim_base_data { size_t length; void *data; }; typedef struct heim_base_data heim_octet_string; #endif typedef struct heim_integer { size_t length; void *data; int negative; } heim_integer; typedef char *heim_general_string; typedef char *heim_utf8_string; typedef struct heim_base_data heim_printable_string; typedef struct heim_base_data heim_ia5_string; typedef struct heim_bmp_string { size_t length; uint16_t *data; } heim_bmp_string; typedef struct heim_universal_string { size_t length; uint32_t *data; } heim_universal_string; typedef char *heim_visible_string; typedef struct heim_oid { size_t length; unsigned *components; } heim_oid; typedef struct heim_bit_string { size_t length; void *data; } heim_bit_string; typedef struct heim_base_data heim_any; typedef struct heim_base_data heim_any_set; #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \ do { \ (BL) = length_##T((S)); \ (B) = malloc((BL)); \ if((B) == NULL) { \ (R) = ENOMEM; \ } else { \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (S), (L)); \ if((R) != 0) { \ free((B)); \ (B) = NULL; \ } \ } \ } while (0) #ifdef _WIN32 #ifndef ASN1_LIB #define ASN1EXP __declspec(dllimport) #else #define ASN1EXP #endif #define ASN1CALL __stdcall #else #define ASN1EXP #define ASN1CALL #endif struct units; #endif /* KX509-ERROR-CODE ::= INTEGER { KX509_STATUS_GOOD(0), KX509_STATUS_CLIENT_BAD(1), KX509_STATUS_CLIENT_FIX(2), KX509_STATUS_CLIENT_TEMP(3), KX509_STATUS_SERVER_BAD(4), KX509_STATUS_SERVER_TEMP(5), KX509_STATUS_SERVER_KEY(7) } */ typedef enum KX509_ERROR_CODE { KX509_STATUS_GOOD = 0, KX509_STATUS_CLIENT_BAD = 1, KX509_STATUS_CLIENT_FIX = 2, KX509_STATUS_CLIENT_TEMP = 3, KX509_STATUS_SERVER_BAD = 4, KX509_STATUS_SERVER_TEMP = 5, KX509_STATUS_SERVER_KEY = 7 } KX509_ERROR_CODE; ASN1EXP int ASN1CALL decode_KX509_ERROR_CODE(const unsigned char *, size_t, KX509_ERROR_CODE *, size_t *); ASN1EXP int ASN1CALL encode_KX509_ERROR_CODE(unsigned char *, size_t, const KX509_ERROR_CODE *, size_t *); ASN1EXP size_t ASN1CALL length_KX509_ERROR_CODE(const KX509_ERROR_CODE *); ASN1EXP int ASN1CALL copy_KX509_ERROR_CODE (const KX509_ERROR_CODE *, KX509_ERROR_CODE *); ASN1EXP void ASN1CALL free_KX509_ERROR_CODE (KX509_ERROR_CODE *); /* Kx509Request ::= SEQUENCE { authenticator OCTET STRING, pk-hash OCTET STRING, pk-key OCTET STRING, } */ typedef struct Kx509Request { heim_octet_string authenticator; heim_octet_string pk_hash; heim_octet_string pk_key; } Kx509Request; ASN1EXP int ASN1CALL decode_Kx509Request(const unsigned char *, size_t, Kx509Request *, size_t *); ASN1EXP int ASN1CALL encode_Kx509Request(unsigned char *, size_t, const Kx509Request *, size_t *); ASN1EXP size_t ASN1CALL length_Kx509Request(const Kx509Request *); ASN1EXP int ASN1CALL copy_Kx509Request (const Kx509Request *, Kx509Request *); ASN1EXP void ASN1CALL free_Kx509Request (Kx509Request *); /* Kx509Response ::= SEQUENCE { error-code [0] INTEGER (-2147483648..2147483647) OPTIONAL, hash [1] OCTET STRING OPTIONAL, certificate [2] OCTET STRING OPTIONAL, e-text [3] VisibleString OPTIONAL, } */ typedef struct Kx509Response { int *error_code; heim_octet_string *hash; heim_octet_string *certificate; heim_visible_string *e_text; } Kx509Response; ASN1EXP int ASN1CALL decode_Kx509Response(const unsigned char *, size_t, Kx509Response *, size_t *); ASN1EXP int ASN1CALL encode_Kx509Response(unsigned char *, size_t, const Kx509Response *, size_t *); ASN1EXP size_t ASN1CALL length_Kx509Response(const Kx509Response *); ASN1EXP int ASN1CALL copy_Kx509Response (const Kx509Response *, Kx509Response *); ASN1EXP void ASN1CALL free_Kx509Response (Kx509Response *); #endif /* __kx509_asn1_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/ntlm_err.h000066400000000000000000000033201505521762700226050ustar00rootroot00000000000000/* Generated from ntlm_err.et */ #ifndef __ntlm_err_h__ #define __ntlm_err_h__ struct et_list; void initialize_ntlm_error_table_r(struct et_list **); void initialize_ntlm_error_table(void); #define init_ntlm_err_tbl initialize_ntlm_error_table typedef enum ntlm_error_number{ HNTLM_ERR_DECODE = -1561745664, HNTLM_ERR_INVALID_LENGTH = -1561745663, HNTLM_ERR_CRYPTO = -1561745662, HNTLM_ERR_RAND = -1561745661, HNTLM_ERR_AUTH = -1561745660, HNTLM_ERR_TIME_SKEW = -1561745659, HNTLM_ERR_OEM = -1561745658, HNTLM_ERR_MISSING_NAME_SEPARATOR = -1561745657, HNTLM_ERR_MISSING_BUFFER = -1561745656, HNTLM_ERR_INVALID_APOP = -1561745655, HNTLM_ERR_INVALID_CRAM_MD5 = -1561745654, HNTLM_ERR_INVALID_DIGEST_MD5 = -1561745653, HNTLM_ERR_INVALID_DIGEST_MD5_RSPAUTH = -1561745652, HNTLM_ERR_INVALID_CHANNEL_BINDINGS = -1561745651, HNTLM_ERR_INVALID_MIC = -1561745650, HNTLM_ERR_INVALID_SESSIONKEY = -1561745649, HNTLM_ERR_NOT_CONFIGURED = -1561745600, HNTLM_ERR_INVALID_CHALLANGE = -1561745599, HNTLM_ERR_INVALID_LMv1_RESPONSE = -1561745598, HNTLM_ERR_INVALID_NT_RESPONSE = -1561745597, HNTLM_ERR_INVALID_LMv2_RESPONSE = -1561745596, HNTLM_ERR_INVALID_NTv1_RESPONSE = -1561745595, HNTLM_ERR_INVALID_NTv2_RESPONSE = -1561745594, HNTLM_ERR_INVALID_NTv1_ANSWER = -1561745593, HNTLM_ERR_INVALID_NTv2_ANSWER = -1561745592, HNTLM_ERR_INVALID_SESSION_KEY = -1561745591, HNTLM_ERR_INVALID_NO_GUEST = -1561745590, HNTLM_ERR_NO_NETR_CONFIGURED = -1561745589, HSCRAM_ERR_INVALID_MESSAGE = -1561745536, HSCRAM_ERR_INVALID_PROOF = -1561745535, HSCRAM_ERR_INVALID_ROLE = -1561745534 } ntlm_error_number; #define ERROR_TABLE_BASE_ntlm -1561745664 #define COM_ERR_BINDDOMAIN_ntlm "heim_com_err-1561745664" #endif /* __ntlm_err_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/ocsp_asn1.h000066400000000000000000000352471505521762700226660ustar00rootroot00000000000000/* Generated from ./ocsp.asn1 */ /* Do not edit */ #ifndef __ocsp_asn1_h__ #define __ocsp_asn1_h__ #include #include #ifndef __asn1_common_definitions__ #define __asn1_common_definitions__ #ifndef __HEIM_BASE_DATA__ #define __HEIM_BASE_DATA__ 1 struct heim_base_data { size_t length; void *data; }; typedef struct heim_base_data heim_octet_string; #endif typedef struct heim_integer { size_t length; void *data; int negative; } heim_integer; typedef char *heim_general_string; typedef char *heim_utf8_string; typedef struct heim_base_data heim_printable_string; typedef struct heim_base_data heim_ia5_string; typedef struct heim_bmp_string { size_t length; uint16_t *data; } heim_bmp_string; typedef struct heim_universal_string { size_t length; uint32_t *data; } heim_universal_string; typedef char *heim_visible_string; typedef struct heim_oid { size_t length; unsigned *components; } heim_oid; typedef struct heim_bit_string { size_t length; void *data; } heim_bit_string; typedef struct heim_base_data heim_any; typedef struct heim_base_data heim_any_set; #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \ do { \ (BL) = length_##T((S)); \ (B) = malloc((BL)); \ if((B) == NULL) { \ (R) = ENOMEM; \ } else { \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (S), (L)); \ if((R) != 0) { \ free((B)); \ (B) = NULL; \ } \ } \ } while (0) #ifdef _WIN32 #ifndef ASN1_LIB #define ASN1EXP __declspec(dllimport) #else #define ASN1EXP #endif #define ASN1CALL __stdcall #else #define ASN1EXP #define ASN1CALL #endif struct units; #endif #include /* OCSPVersion ::= INTEGER { ocsp_v1(0) } */ typedef enum OCSPVersion { ocsp_v1 = 0 } OCSPVersion; ASN1EXP int ASN1CALL decode_OCSPVersion(const unsigned char *, size_t, OCSPVersion *, size_t *); ASN1EXP int ASN1CALL encode_OCSPVersion(unsigned char *, size_t, const OCSPVersion *, size_t *); ASN1EXP size_t ASN1CALL length_OCSPVersion(const OCSPVersion *); ASN1EXP int ASN1CALL copy_OCSPVersion (const OCSPVersion *, OCSPVersion *); ASN1EXP void ASN1CALL free_OCSPVersion (OCSPVersion *); /* OCSPCertStatus ::= CHOICE { good [0] IMPLICIT NULL, revoked [1] IMPLICIT SEQUENCE { revocationTime GeneralizedTime, revocationReason [0] CRLReason OPTIONAL, }, unknown [2] IMPLICIT NULL, } */ typedef struct OCSPCertStatus { enum OCSPCertStatus_enum { choice_OCSPCertStatus_good = 1, choice_OCSPCertStatus_revoked, choice_OCSPCertStatus_unknown } element; union { int good; struct OCSPCertStatus_revoked { time_t revocationTime; CRLReason *revocationReason; } revoked; int unknown; } u; } OCSPCertStatus; ASN1EXP int ASN1CALL decode_OCSPCertStatus(const unsigned char *, size_t, OCSPCertStatus *, size_t *); ASN1EXP int ASN1CALL encode_OCSPCertStatus(unsigned char *, size_t, const OCSPCertStatus *, size_t *); ASN1EXP size_t ASN1CALL length_OCSPCertStatus(const OCSPCertStatus *); ASN1EXP int ASN1CALL copy_OCSPCertStatus (const OCSPCertStatus *, OCSPCertStatus *); ASN1EXP void ASN1CALL free_OCSPCertStatus (OCSPCertStatus *); /* OCSPCertID ::= SEQUENCE { hashAlgorithm AlgorithmIdentifier, issuerNameHash OCTET STRING, issuerKeyHash OCTET STRING, serialNumber CertificateSerialNumber, } */ typedef struct OCSPCertID { AlgorithmIdentifier hashAlgorithm; heim_octet_string issuerNameHash; heim_octet_string issuerKeyHash; CertificateSerialNumber serialNumber; } OCSPCertID; ASN1EXP int ASN1CALL decode_OCSPCertID(const unsigned char *, size_t, OCSPCertID *, size_t *); ASN1EXP int ASN1CALL encode_OCSPCertID(unsigned char *, size_t, const OCSPCertID *, size_t *); ASN1EXP size_t ASN1CALL length_OCSPCertID(const OCSPCertID *); ASN1EXP int ASN1CALL copy_OCSPCertID (const OCSPCertID *, OCSPCertID *); ASN1EXP void ASN1CALL free_OCSPCertID (OCSPCertID *); /* OCSPSingleResponse ::= SEQUENCE { certID OCSPCertID, certStatus OCSPCertStatus, thisUpdate GeneralizedTime, nextUpdate [0] GeneralizedTime OPTIONAL, singleExtensions [1] Extensions OPTIONAL, } */ typedef struct OCSPSingleResponse { OCSPCertID certID; OCSPCertStatus certStatus; time_t thisUpdate; time_t *nextUpdate; Extensions *singleExtensions; } OCSPSingleResponse; ASN1EXP int ASN1CALL decode_OCSPSingleResponse(const unsigned char *, size_t, OCSPSingleResponse *, size_t *); ASN1EXP int ASN1CALL encode_OCSPSingleResponse(unsigned char *, size_t, const OCSPSingleResponse *, size_t *); ASN1EXP size_t ASN1CALL length_OCSPSingleResponse(const OCSPSingleResponse *); ASN1EXP int ASN1CALL copy_OCSPSingleResponse (const OCSPSingleResponse *, OCSPSingleResponse *); ASN1EXP void ASN1CALL free_OCSPSingleResponse (OCSPSingleResponse *); /* OCSPInnerRequest ::= SEQUENCE { reqCert OCSPCertID, singleRequestExtensions [0] Extensions OPTIONAL, } */ typedef struct OCSPInnerRequest { OCSPCertID reqCert; Extensions *singleRequestExtensions; } OCSPInnerRequest; ASN1EXP int ASN1CALL decode_OCSPInnerRequest(const unsigned char *, size_t, OCSPInnerRequest *, size_t *); ASN1EXP int ASN1CALL encode_OCSPInnerRequest(unsigned char *, size_t, const OCSPInnerRequest *, size_t *); ASN1EXP size_t ASN1CALL length_OCSPInnerRequest(const OCSPInnerRequest *); ASN1EXP int ASN1CALL copy_OCSPInnerRequest (const OCSPInnerRequest *, OCSPInnerRequest *); ASN1EXP void ASN1CALL free_OCSPInnerRequest (OCSPInnerRequest *); /* OCSPTBSRequest ::= SEQUENCE { version [0] OCSPVersion OPTIONAL, requestorName [1] GeneralName OPTIONAL, requestList SEQUENCE OF OCSPInnerRequest, requestExtensions [2] Extensions OPTIONAL, } */ typedef struct OCSPTBSRequest { heim_octet_string _save; OCSPVersion *version; GeneralName *requestorName; struct OCSPTBSRequest_requestList { unsigned int len; OCSPInnerRequest *val; } requestList; Extensions *requestExtensions; } OCSPTBSRequest; ASN1EXP int ASN1CALL decode_OCSPTBSRequest(const unsigned char *, size_t, OCSPTBSRequest *, size_t *); ASN1EXP int ASN1CALL encode_OCSPTBSRequest(unsigned char *, size_t, const OCSPTBSRequest *, size_t *); ASN1EXP size_t ASN1CALL length_OCSPTBSRequest(const OCSPTBSRequest *); ASN1EXP int ASN1CALL copy_OCSPTBSRequest (const OCSPTBSRequest *, OCSPTBSRequest *); ASN1EXP void ASN1CALL free_OCSPTBSRequest (OCSPTBSRequest *); /* OCSPSignature ::= SEQUENCE { signatureAlgorithm AlgorithmIdentifier, signature BIT STRING { }, certs [0] SEQUENCE OF Certificate OPTIONAL, } */ typedef struct OCSPSignature { AlgorithmIdentifier signatureAlgorithm; heim_bit_string signature; struct OCSPSignature_certs { unsigned int len; Certificate *val; } *certs; } OCSPSignature; ASN1EXP int ASN1CALL decode_OCSPSignature(const unsigned char *, size_t, OCSPSignature *, size_t *); ASN1EXP int ASN1CALL encode_OCSPSignature(unsigned char *, size_t, const OCSPSignature *, size_t *); ASN1EXP size_t ASN1CALL length_OCSPSignature(const OCSPSignature *); ASN1EXP int ASN1CALL copy_OCSPSignature (const OCSPSignature *, OCSPSignature *); ASN1EXP void ASN1CALL free_OCSPSignature (OCSPSignature *); /* OCSPRequest ::= SEQUENCE { tbsRequest OCSPTBSRequest, optionalSignature [0] OCSPSignature OPTIONAL, } */ typedef struct OCSPRequest { OCSPTBSRequest tbsRequest; OCSPSignature *optionalSignature; } OCSPRequest; ASN1EXP int ASN1CALL decode_OCSPRequest(const unsigned char *, size_t, OCSPRequest *, size_t *); ASN1EXP int ASN1CALL encode_OCSPRequest(unsigned char *, size_t, const OCSPRequest *, size_t *); ASN1EXP size_t ASN1CALL length_OCSPRequest(const OCSPRequest *); ASN1EXP int ASN1CALL copy_OCSPRequest (const OCSPRequest *, OCSPRequest *); ASN1EXP void ASN1CALL free_OCSPRequest (OCSPRequest *); /* OCSPResponseBytes ::= SEQUENCE { responseType OBJECT IDENTIFIER, response OCTET STRING, } */ typedef struct OCSPResponseBytes { heim_oid responseType; heim_octet_string response; } OCSPResponseBytes; ASN1EXP int ASN1CALL decode_OCSPResponseBytes(const unsigned char *, size_t, OCSPResponseBytes *, size_t *); ASN1EXP int ASN1CALL encode_OCSPResponseBytes(unsigned char *, size_t, const OCSPResponseBytes *, size_t *); ASN1EXP size_t ASN1CALL length_OCSPResponseBytes(const OCSPResponseBytes *); ASN1EXP int ASN1CALL copy_OCSPResponseBytes (const OCSPResponseBytes *, OCSPResponseBytes *); ASN1EXP void ASN1CALL free_OCSPResponseBytes (OCSPResponseBytes *); /* OCSPResponseStatus ::= INTEGER { successful(0), malformedRequest(1), internalError(2), tryLater(3), sigRequired(5), unauthorized(6) } */ typedef enum OCSPResponseStatus { successful = 0, malformedRequest = 1, internalError = 2, tryLater = 3, sigRequired = 5, unauthorized = 6 } OCSPResponseStatus; ASN1EXP int ASN1CALL decode_OCSPResponseStatus(const unsigned char *, size_t, OCSPResponseStatus *, size_t *); ASN1EXP int ASN1CALL encode_OCSPResponseStatus(unsigned char *, size_t, const OCSPResponseStatus *, size_t *); ASN1EXP size_t ASN1CALL length_OCSPResponseStatus(const OCSPResponseStatus *); ASN1EXP int ASN1CALL copy_OCSPResponseStatus (const OCSPResponseStatus *, OCSPResponseStatus *); ASN1EXP void ASN1CALL free_OCSPResponseStatus (OCSPResponseStatus *); /* OCSPResponse ::= SEQUENCE { responseStatus OCSPResponseStatus, responseBytes [0] OCSPResponseBytes OPTIONAL, } */ typedef struct OCSPResponse { OCSPResponseStatus responseStatus; OCSPResponseBytes *responseBytes; } OCSPResponse; ASN1EXP int ASN1CALL decode_OCSPResponse(const unsigned char *, size_t, OCSPResponse *, size_t *); ASN1EXP int ASN1CALL encode_OCSPResponse(unsigned char *, size_t, const OCSPResponse *, size_t *); ASN1EXP size_t ASN1CALL length_OCSPResponse(const OCSPResponse *); ASN1EXP int ASN1CALL copy_OCSPResponse (const OCSPResponse *, OCSPResponse *); ASN1EXP void ASN1CALL free_OCSPResponse (OCSPResponse *); /* OCSPKeyHash ::= OCTET STRING */ typedef heim_octet_string OCSPKeyHash; ASN1EXP int ASN1CALL decode_OCSPKeyHash(const unsigned char *, size_t, OCSPKeyHash *, size_t *); ASN1EXP int ASN1CALL encode_OCSPKeyHash(unsigned char *, size_t, const OCSPKeyHash *, size_t *); ASN1EXP size_t ASN1CALL length_OCSPKeyHash(const OCSPKeyHash *); ASN1EXP int ASN1CALL copy_OCSPKeyHash (const OCSPKeyHash *, OCSPKeyHash *); ASN1EXP void ASN1CALL free_OCSPKeyHash (OCSPKeyHash *); /* OCSPResponderID ::= CHOICE { byName [1] Name, byKey [2] OCSPKeyHash, } */ typedef struct OCSPResponderID { enum OCSPResponderID_enum { choice_OCSPResponderID_byName = 1, choice_OCSPResponderID_byKey } element; union { Name byName; OCSPKeyHash byKey; } u; } OCSPResponderID; ASN1EXP int ASN1CALL decode_OCSPResponderID(const unsigned char *, size_t, OCSPResponderID *, size_t *); ASN1EXP int ASN1CALL encode_OCSPResponderID(unsigned char *, size_t, const OCSPResponderID *, size_t *); ASN1EXP size_t ASN1CALL length_OCSPResponderID(const OCSPResponderID *); ASN1EXP int ASN1CALL copy_OCSPResponderID (const OCSPResponderID *, OCSPResponderID *); ASN1EXP void ASN1CALL free_OCSPResponderID (OCSPResponderID *); /* OCSPResponseData ::= SEQUENCE { version [0] OCSPVersion OPTIONAL, responderID OCSPResponderID, producedAt GeneralizedTime, responses SEQUENCE OF OCSPSingleResponse, responseExtensions [1] Extensions OPTIONAL, } */ typedef struct OCSPResponseData { heim_octet_string _save; OCSPVersion *version; OCSPResponderID responderID; time_t producedAt; struct OCSPResponseData_responses { unsigned int len; OCSPSingleResponse *val; } responses; Extensions *responseExtensions; } OCSPResponseData; ASN1EXP int ASN1CALL decode_OCSPResponseData(const unsigned char *, size_t, OCSPResponseData *, size_t *); ASN1EXP int ASN1CALL encode_OCSPResponseData(unsigned char *, size_t, const OCSPResponseData *, size_t *); ASN1EXP size_t ASN1CALL length_OCSPResponseData(const OCSPResponseData *); ASN1EXP int ASN1CALL copy_OCSPResponseData (const OCSPResponseData *, OCSPResponseData *); ASN1EXP void ASN1CALL free_OCSPResponseData (OCSPResponseData *); /* OCSPBasicOCSPResponse ::= SEQUENCE { tbsResponseData OCSPResponseData, signatureAlgorithm AlgorithmIdentifier, signature BIT STRING { }, certs [0] SEQUENCE OF Certificate OPTIONAL, } */ typedef struct OCSPBasicOCSPResponse { OCSPResponseData tbsResponseData; AlgorithmIdentifier signatureAlgorithm; heim_bit_string signature; struct OCSPBasicOCSPResponse_certs { unsigned int len; Certificate *val; } *certs; } OCSPBasicOCSPResponse; ASN1EXP int ASN1CALL decode_OCSPBasicOCSPResponse(const unsigned char *, size_t, OCSPBasicOCSPResponse *, size_t *); ASN1EXP int ASN1CALL encode_OCSPBasicOCSPResponse(unsigned char *, size_t, const OCSPBasicOCSPResponse *, size_t *); ASN1EXP size_t ASN1CALL length_OCSPBasicOCSPResponse(const OCSPBasicOCSPResponse *); ASN1EXP int ASN1CALL copy_OCSPBasicOCSPResponse (const OCSPBasicOCSPResponse *, OCSPBasicOCSPResponse *); ASN1EXP void ASN1CALL free_OCSPBasicOCSPResponse (OCSPBasicOCSPResponse *); /* OBJECT IDENTIFIER id-pkix-ocsp ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) pkix-ad(48) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix_ocsp; #define ASN1_OID_ID_PKIX_OCSP (&asn1_oid_id_pkix_ocsp) /* OBJECT IDENTIFIER id-pkix-ocsp-basic ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) pkix-ad(48) label-less(1) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix_ocsp_basic; #define ASN1_OID_ID_PKIX_OCSP_BASIC (&asn1_oid_id_pkix_ocsp_basic) /* OBJECT IDENTIFIER id-pkix-ocsp-nonce ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) pkix-ad(48) label-less(1) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix_ocsp_nonce; #define ASN1_OID_ID_PKIX_OCSP_NONCE (&asn1_oid_id_pkix_ocsp_nonce) #endif /* __ocsp_asn1_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/parse_bytes.h000066400000000000000000000042021505521762700233030ustar00rootroot00000000000000/* * Copyright (c) 1999 - 2001 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef __PARSE_BYTES_H__ #define __PARSE_BYTES_H__ #ifndef ROKEN_LIB_FUNCTION #ifdef _WIN32 #define ROKEN_LIB_FUNCTION #define ROKEN_LIB_CALL __cdecl #else #define ROKEN_LIB_FUNCTION #define ROKEN_LIB_CALL #endif #endif ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL parse_bytes (const char *s, const char *def_unit); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL unparse_bytes (int t, char *s, size_t len); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL unparse_bytes_short (int t, char *s, size_t len); #endif /* __PARSE_BYTES_H__ */ pykrb5-0.8.0/build_helpers/heimdal/include/parse_time.h000066400000000000000000000043001505521762700231120ustar00rootroot00000000000000/* * Copyright (c) 1997 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef __PARSE_TIME_H__ #define __PARSE_TIME_H__ #ifndef ROKEN_LIB_FUNCTION #ifdef _WIN32 #define ROKEN_LIB_FUNCTION #define ROKEN_LIB_CALL __cdecl #else #define ROKEN_LIB_FUNCTION #define ROKEN_LIB_CALL #endif #endif ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL parse_time (const char *s, const char *def_unit); ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL unparse_time (int t, char *s, size_t len); ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL unparse_time_approx (int t, char *s, size_t len); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL print_time_table (FILE *f); #endif /* __PARSE_TIME_H__ */ pykrb5-0.8.0/build_helpers/heimdal/include/parse_units.h000066400000000000000000000053511505521762700233250ustar00rootroot00000000000000/* * Copyright (c) 1997 - 2001 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef __PARSE_UNITS_H__ #define __PARSE_UNITS_H__ #include #include #ifndef ROKEN_LIB_FUNCTION #ifdef _WIN32 #define ROKEN_LIB_FUNCTION #define ROKEN_LIB_CALL __cdecl #else #define ROKEN_LIB_FUNCTION #define ROKEN_LIB_CALL #endif #endif struct units { const char *name; unsigned mult; }; ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL parse_units (const char *s, const struct units *units, const char *def_unit); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL print_units_table (const struct units *units, FILE *f); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL parse_flags (const char *s, const struct units *units, int orig); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL unparse_units (int num, const struct units *units, char *s, size_t len); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL unparse_units_approx (int num, const struct units *units, char *s, size_t len); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL unparse_flags (int num, const struct units *units, char *s, size_t len); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL print_flags_table (const struct units *units, FILE *f); #endif /* __PARSE_UNITS_H__ */ pykrb5-0.8.0/build_helpers/heimdal/include/pkcs10_asn1.h000066400000000000000000000102531505521762700230110ustar00rootroot00000000000000/* Generated from ./pkcs10.asn1 */ /* Do not edit */ #ifndef __pkcs10_asn1_h__ #define __pkcs10_asn1_h__ #include #include #ifndef __asn1_common_definitions__ #define __asn1_common_definitions__ #ifndef __HEIM_BASE_DATA__ #define __HEIM_BASE_DATA__ 1 struct heim_base_data { size_t length; void *data; }; typedef struct heim_base_data heim_octet_string; #endif typedef struct heim_integer { size_t length; void *data; int negative; } heim_integer; typedef char *heim_general_string; typedef char *heim_utf8_string; typedef struct heim_base_data heim_printable_string; typedef struct heim_base_data heim_ia5_string; typedef struct heim_bmp_string { size_t length; uint16_t *data; } heim_bmp_string; typedef struct heim_universal_string { size_t length; uint32_t *data; } heim_universal_string; typedef char *heim_visible_string; typedef struct heim_oid { size_t length; unsigned *components; } heim_oid; typedef struct heim_bit_string { size_t length; void *data; } heim_bit_string; typedef struct heim_base_data heim_any; typedef struct heim_base_data heim_any_set; #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \ do { \ (BL) = length_##T((S)); \ (B) = malloc((BL)); \ if((B) == NULL) { \ (R) = ENOMEM; \ } else { \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (S), (L)); \ if((R) != 0) { \ free((B)); \ (B) = NULL; \ } \ } \ } while (0) #ifdef _WIN32 #ifndef ASN1_LIB #define ASN1EXP __declspec(dllimport) #else #define ASN1EXP #endif #define ASN1CALL __stdcall #else #define ASN1EXP #define ASN1CALL #endif struct units; #endif #include /* CertificationRequestInfo ::= SEQUENCE { version INTEGER { pkcs10_v1(0) }, subject Name, subjectPKInfo SubjectPublicKeyInfo, attributes [0] IMPLICIT SET OF Attribute OPTIONAL, } */ typedef struct CertificationRequestInfo { heim_octet_string _save; enum { pkcs10_v1 = 0 } version; Name subject; SubjectPublicKeyInfo subjectPKInfo; struct CertificationRequestInfo_attributes { unsigned int len; Attribute *val; } *attributes; } CertificationRequestInfo; ASN1EXP int ASN1CALL decode_CertificationRequestInfo(const unsigned char *, size_t, CertificationRequestInfo *, size_t *); ASN1EXP int ASN1CALL encode_CertificationRequestInfo(unsigned char *, size_t, const CertificationRequestInfo *, size_t *); ASN1EXP size_t ASN1CALL length_CertificationRequestInfo(const CertificationRequestInfo *); ASN1EXP int ASN1CALL copy_CertificationRequestInfo (const CertificationRequestInfo *, CertificationRequestInfo *); ASN1EXP void ASN1CALL free_CertificationRequestInfo (CertificationRequestInfo *); /* CertificationRequest ::= SEQUENCE { certificationRequestInfo CertificationRequestInfo, signatureAlgorithm AlgorithmIdentifier, signature BIT STRING { }, } */ typedef struct CertificationRequest { CertificationRequestInfo certificationRequestInfo; AlgorithmIdentifier signatureAlgorithm; heim_bit_string signature; } CertificationRequest; ASN1EXP int ASN1CALL decode_CertificationRequest(const unsigned char *, size_t, CertificationRequest *, size_t *); ASN1EXP int ASN1CALL encode_CertificationRequest(unsigned char *, size_t, const CertificationRequest *, size_t *); ASN1EXP size_t ASN1CALL length_CertificationRequest(const CertificationRequest *); ASN1EXP int ASN1CALL copy_CertificationRequest (const CertificationRequest *, CertificationRequest *); ASN1EXP void ASN1CALL free_CertificationRequest (CertificationRequest *); #endif /* __pkcs10_asn1_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/pkcs12_asn1.h000066400000000000000000000321401505521762700230120ustar00rootroot00000000000000/* Generated from ./pkcs12.asn1 */ /* Do not edit */ #ifndef __pkcs12_asn1_h__ #define __pkcs12_asn1_h__ #include #include #ifndef __asn1_common_definitions__ #define __asn1_common_definitions__ #ifndef __HEIM_BASE_DATA__ #define __HEIM_BASE_DATA__ 1 struct heim_base_data { size_t length; void *data; }; typedef struct heim_base_data heim_octet_string; #endif typedef struct heim_integer { size_t length; void *data; int negative; } heim_integer; typedef char *heim_general_string; typedef char *heim_utf8_string; typedef struct heim_base_data heim_printable_string; typedef struct heim_base_data heim_ia5_string; typedef struct heim_bmp_string { size_t length; uint16_t *data; } heim_bmp_string; typedef struct heim_universal_string { size_t length; uint32_t *data; } heim_universal_string; typedef char *heim_visible_string; typedef struct heim_oid { size_t length; unsigned *components; } heim_oid; typedef struct heim_bit_string { size_t length; void *data; } heim_bit_string; typedef struct heim_base_data heim_any; typedef struct heim_base_data heim_any_set; #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \ do { \ (BL) = length_##T((S)); \ (B) = malloc((BL)); \ if((B) == NULL) { \ (R) = ENOMEM; \ } else { \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (S), (L)); \ if((R) != 0) { \ free((B)); \ (B) = NULL; \ } \ } \ } while (0) #ifdef _WIN32 #ifndef ASN1_LIB #define ASN1EXP __declspec(dllimport) #else #define ASN1EXP #endif #define ASN1CALL __stdcall #else #define ASN1EXP #define ASN1CALL #endif struct units; #endif #include #include #include /* OBJECT IDENTIFIER id-pkcs-12 ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs_12; #define ASN1_OID_ID_PKCS_12 (&asn1_oid_id_pkcs_12) /* OBJECT IDENTIFIER id-pkcs-12PbeIds ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs_12PbeIds; #define ASN1_OID_ID_PKCS_12PBEIDS (&asn1_oid_id_pkcs_12PbeIds) /* OBJECT IDENTIFIER id-pbeWithSHAAnd128BitRC4 ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(1) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_pbeWithSHAAnd128BitRC4; #define ASN1_OID_ID_PBEWITHSHAAND128BITRC4 (&asn1_oid_id_pbeWithSHAAnd128BitRC4) /* OBJECT IDENTIFIER id-pbeWithSHAAnd40BitRC4 ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(1) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_pbeWithSHAAnd40BitRC4; #define ASN1_OID_ID_PBEWITHSHAAND40BITRC4 (&asn1_oid_id_pbeWithSHAAnd40BitRC4) /* OBJECT IDENTIFIER id-pbeWithSHAAnd3-KeyTripleDES-CBC ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(1) label-less(3) } */ extern ASN1EXP const heim_oid asn1_oid_id_pbeWithSHAAnd3_KeyTripleDES_CBC; #define ASN1_OID_ID_PBEWITHSHAAND3_KEYTRIPLEDES_CBC (&asn1_oid_id_pbeWithSHAAnd3_KeyTripleDES_CBC) /* OBJECT IDENTIFIER id-pbeWithSHAAnd2-KeyTripleDES-CBC ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(1) label-less(4) } */ extern ASN1EXP const heim_oid asn1_oid_id_pbeWithSHAAnd2_KeyTripleDES_CBC; #define ASN1_OID_ID_PBEWITHSHAAND2_KEYTRIPLEDES_CBC (&asn1_oid_id_pbeWithSHAAnd2_KeyTripleDES_CBC) /* OBJECT IDENTIFIER id-pbeWithSHAAnd128BitRC2-CBC ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(1) label-less(5) } */ extern ASN1EXP const heim_oid asn1_oid_id_pbeWithSHAAnd128BitRC2_CBC; #define ASN1_OID_ID_PBEWITHSHAAND128BITRC2_CBC (&asn1_oid_id_pbeWithSHAAnd128BitRC2_CBC) /* OBJECT IDENTIFIER id-pbewithSHAAnd40BitRC2-CBC ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(1) label-less(6) } */ extern ASN1EXP const heim_oid asn1_oid_id_pbewithSHAAnd40BitRC2_CBC; #define ASN1_OID_ID_PBEWITHSHAAND40BITRC2_CBC (&asn1_oid_id_pbewithSHAAnd40BitRC2_CBC) /* OBJECT IDENTIFIER id-pkcs12-bagtypes ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs12_bagtypes; #define ASN1_OID_ID_PKCS12_BAGTYPES (&asn1_oid_id_pkcs12_bagtypes) /* OBJECT IDENTIFIER id-pkcs12-keyBag ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs12_keyBag; #define ASN1_OID_ID_PKCS12_KEYBAG (&asn1_oid_id_pkcs12_keyBag) /* OBJECT IDENTIFIER id-pkcs12-pkcs8ShroudedKeyBag ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs12_pkcs8ShroudedKeyBag; #define ASN1_OID_ID_PKCS12_PKCS8SHROUDEDKEYBAG (&asn1_oid_id_pkcs12_pkcs8ShroudedKeyBag) /* OBJECT IDENTIFIER id-pkcs12-certBag ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) label-less(3) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs12_certBag; #define ASN1_OID_ID_PKCS12_CERTBAG (&asn1_oid_id_pkcs12_certBag) /* OBJECT IDENTIFIER id-pkcs12-crlBag ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) label-less(4) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs12_crlBag; #define ASN1_OID_ID_PKCS12_CRLBAG (&asn1_oid_id_pkcs12_crlBag) /* OBJECT IDENTIFIER id-pkcs12-secretBag ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) label-less(5) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs12_secretBag; #define ASN1_OID_ID_PKCS12_SECRETBAG (&asn1_oid_id_pkcs12_secretBag) /* OBJECT IDENTIFIER id-pkcs12-safeContentsBag ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-12(12) label-less(10) label-less(1) label-less(6) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs12_safeContentsBag; #define ASN1_OID_ID_PKCS12_SAFECONTENTSBAG (&asn1_oid_id_pkcs12_safeContentsBag) /* PKCS12-MacData ::= SEQUENCE { mac DigestInfo, macSalt OCTET STRING, iterations INTEGER OPTIONAL, } */ typedef struct PKCS12_MacData { DigestInfo mac; heim_octet_string macSalt; heim_integer *iterations; } PKCS12_MacData; ASN1EXP int ASN1CALL decode_PKCS12_MacData(const unsigned char *, size_t, PKCS12_MacData *, size_t *); ASN1EXP int ASN1CALL encode_PKCS12_MacData(unsigned char *, size_t, const PKCS12_MacData *, size_t *); ASN1EXP size_t ASN1CALL length_PKCS12_MacData(const PKCS12_MacData *); ASN1EXP int ASN1CALL copy_PKCS12_MacData (const PKCS12_MacData *, PKCS12_MacData *); ASN1EXP void ASN1CALL free_PKCS12_MacData (PKCS12_MacData *); /* PKCS12-PFX ::= SEQUENCE { version INTEGER, authSafe ContentInfo, macData PKCS12-MacData OPTIONAL, } */ typedef struct PKCS12_PFX { heim_integer version; ContentInfo authSafe; PKCS12_MacData *macData; } PKCS12_PFX; ASN1EXP int ASN1CALL decode_PKCS12_PFX(const unsigned char *, size_t, PKCS12_PFX *, size_t *); ASN1EXP int ASN1CALL encode_PKCS12_PFX(unsigned char *, size_t, const PKCS12_PFX *, size_t *); ASN1EXP size_t ASN1CALL length_PKCS12_PFX(const PKCS12_PFX *); ASN1EXP int ASN1CALL copy_PKCS12_PFX (const PKCS12_PFX *, PKCS12_PFX *); ASN1EXP void ASN1CALL free_PKCS12_PFX (PKCS12_PFX *); /* PKCS12-AuthenticatedSafe ::= SEQUENCE OF ContentInfo */ typedef struct PKCS12_AuthenticatedSafe { unsigned int len; ContentInfo *val; } PKCS12_AuthenticatedSafe; ASN1EXP int ASN1CALL decode_PKCS12_AuthenticatedSafe(const unsigned char *, size_t, PKCS12_AuthenticatedSafe *, size_t *); ASN1EXP int ASN1CALL encode_PKCS12_AuthenticatedSafe(unsigned char *, size_t, const PKCS12_AuthenticatedSafe *, size_t *); ASN1EXP size_t ASN1CALL length_PKCS12_AuthenticatedSafe(const PKCS12_AuthenticatedSafe *); ASN1EXP int ASN1CALL copy_PKCS12_AuthenticatedSafe (const PKCS12_AuthenticatedSafe *, PKCS12_AuthenticatedSafe *); ASN1EXP void ASN1CALL free_PKCS12_AuthenticatedSafe (PKCS12_AuthenticatedSafe *); /* PKCS12-Attribute ::= SEQUENCE { attrId OBJECT IDENTIFIER, attrValues heim_any_set, } */ typedef struct PKCS12_Attribute { heim_oid attrId; heim_any_set attrValues; } PKCS12_Attribute; ASN1EXP int ASN1CALL decode_PKCS12_Attribute(const unsigned char *, size_t, PKCS12_Attribute *, size_t *); ASN1EXP int ASN1CALL encode_PKCS12_Attribute(unsigned char *, size_t, const PKCS12_Attribute *, size_t *); ASN1EXP size_t ASN1CALL length_PKCS12_Attribute(const PKCS12_Attribute *); ASN1EXP int ASN1CALL copy_PKCS12_Attribute (const PKCS12_Attribute *, PKCS12_Attribute *); ASN1EXP void ASN1CALL free_PKCS12_Attribute (PKCS12_Attribute *); /* PKCS12-Attributes ::= SET OF PKCS12-Attribute */ typedef struct PKCS12_Attributes { unsigned int len; PKCS12_Attribute *val; } PKCS12_Attributes; ASN1EXP int ASN1CALL decode_PKCS12_Attributes(const unsigned char *, size_t, PKCS12_Attributes *, size_t *); ASN1EXP int ASN1CALL encode_PKCS12_Attributes(unsigned char *, size_t, const PKCS12_Attributes *, size_t *); ASN1EXP size_t ASN1CALL length_PKCS12_Attributes(const PKCS12_Attributes *); ASN1EXP int ASN1CALL copy_PKCS12_Attributes (const PKCS12_Attributes *, PKCS12_Attributes *); ASN1EXP void ASN1CALL free_PKCS12_Attributes (PKCS12_Attributes *); /* PKCS12-SafeBag ::= SEQUENCE { bagId OBJECT IDENTIFIER, bagValue [0] heim_any, bagAttributes PKCS12-Attributes OPTIONAL, } */ typedef struct PKCS12_SafeBag { heim_oid bagId; heim_any bagValue; PKCS12_Attributes *bagAttributes; } PKCS12_SafeBag; ASN1EXP int ASN1CALL decode_PKCS12_SafeBag(const unsigned char *, size_t, PKCS12_SafeBag *, size_t *); ASN1EXP int ASN1CALL encode_PKCS12_SafeBag(unsigned char *, size_t, const PKCS12_SafeBag *, size_t *); ASN1EXP size_t ASN1CALL length_PKCS12_SafeBag(const PKCS12_SafeBag *); ASN1EXP int ASN1CALL copy_PKCS12_SafeBag (const PKCS12_SafeBag *, PKCS12_SafeBag *); ASN1EXP void ASN1CALL free_PKCS12_SafeBag (PKCS12_SafeBag *); /* PKCS12-SafeContents ::= SEQUENCE OF PKCS12-SafeBag */ typedef struct PKCS12_SafeContents { unsigned int len; PKCS12_SafeBag *val; } PKCS12_SafeContents; ASN1EXP int ASN1CALL decode_PKCS12_SafeContents(const unsigned char *, size_t, PKCS12_SafeContents *, size_t *); ASN1EXP int ASN1CALL encode_PKCS12_SafeContents(unsigned char *, size_t, const PKCS12_SafeContents *, size_t *); ASN1EXP size_t ASN1CALL length_PKCS12_SafeContents(const PKCS12_SafeContents *); ASN1EXP int ASN1CALL copy_PKCS12_SafeContents (const PKCS12_SafeContents *, PKCS12_SafeContents *); ASN1EXP void ASN1CALL free_PKCS12_SafeContents (PKCS12_SafeContents *); /* PKCS12-CertBag ::= SEQUENCE { certType OBJECT IDENTIFIER, certValue [0] heim_any, } */ typedef struct PKCS12_CertBag { heim_oid certType; heim_any certValue; } PKCS12_CertBag; ASN1EXP int ASN1CALL decode_PKCS12_CertBag(const unsigned char *, size_t, PKCS12_CertBag *, size_t *); ASN1EXP int ASN1CALL encode_PKCS12_CertBag(unsigned char *, size_t, const PKCS12_CertBag *, size_t *); ASN1EXP size_t ASN1CALL length_PKCS12_CertBag(const PKCS12_CertBag *); ASN1EXP int ASN1CALL copy_PKCS12_CertBag (const PKCS12_CertBag *, PKCS12_CertBag *); ASN1EXP void ASN1CALL free_PKCS12_CertBag (PKCS12_CertBag *); /* PKCS12-PBEParams ::= SEQUENCE { salt OCTET STRING, iterations INTEGER (0..4294967295) OPTIONAL, } */ typedef struct PKCS12_PBEParams { heim_octet_string salt; unsigned int *iterations; } PKCS12_PBEParams; ASN1EXP int ASN1CALL decode_PKCS12_PBEParams(const unsigned char *, size_t, PKCS12_PBEParams *, size_t *); ASN1EXP int ASN1CALL encode_PKCS12_PBEParams(unsigned char *, size_t, const PKCS12_PBEParams *, size_t *); ASN1EXP size_t ASN1CALL length_PKCS12_PBEParams(const PKCS12_PBEParams *); ASN1EXP int ASN1CALL copy_PKCS12_PBEParams (const PKCS12_PBEParams *, PKCS12_PBEParams *); ASN1EXP void ASN1CALL free_PKCS12_PBEParams (PKCS12_PBEParams *); /* PKCS12-OctetString ::= OCTET STRING */ typedef heim_octet_string PKCS12_OctetString; ASN1EXP int ASN1CALL decode_PKCS12_OctetString(const unsigned char *, size_t, PKCS12_OctetString *, size_t *); ASN1EXP int ASN1CALL encode_PKCS12_OctetString(unsigned char *, size_t, const PKCS12_OctetString *, size_t *); ASN1EXP size_t ASN1CALL length_PKCS12_OctetString(const PKCS12_OctetString *); ASN1EXP int ASN1CALL copy_PKCS12_OctetString (const PKCS12_OctetString *, PKCS12_OctetString *); ASN1EXP void ASN1CALL free_PKCS12_OctetString (PKCS12_OctetString *); #endif /* __pkcs12_asn1_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/pkcs8_asn1.h000066400000000000000000000150711505521762700227430ustar00rootroot00000000000000/* Generated from ./pkcs8.asn1 */ /* Do not edit */ #ifndef __pkcs8_asn1_h__ #define __pkcs8_asn1_h__ #include #include #ifndef __asn1_common_definitions__ #define __asn1_common_definitions__ #ifndef __HEIM_BASE_DATA__ #define __HEIM_BASE_DATA__ 1 struct heim_base_data { size_t length; void *data; }; typedef struct heim_base_data heim_octet_string; #endif typedef struct heim_integer { size_t length; void *data; int negative; } heim_integer; typedef char *heim_general_string; typedef char *heim_utf8_string; typedef struct heim_base_data heim_printable_string; typedef struct heim_base_data heim_ia5_string; typedef struct heim_bmp_string { size_t length; uint16_t *data; } heim_bmp_string; typedef struct heim_universal_string { size_t length; uint32_t *data; } heim_universal_string; typedef char *heim_visible_string; typedef struct heim_oid { size_t length; unsigned *components; } heim_oid; typedef struct heim_bit_string { size_t length; void *data; } heim_bit_string; typedef struct heim_base_data heim_any; typedef struct heim_base_data heim_any_set; #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \ do { \ (BL) = length_##T((S)); \ (B) = malloc((BL)); \ if((B) == NULL) { \ (R) = ENOMEM; \ } else { \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (S), (L)); \ if((R) != 0) { \ free((B)); \ (B) = NULL; \ } \ } \ } while (0) #ifdef _WIN32 #ifndef ASN1_LIB #define ASN1EXP __declspec(dllimport) #else #define ASN1EXP #endif #define ASN1CALL __stdcall #else #define ASN1EXP #define ASN1CALL #endif struct units; #endif #include #include /* PKCS8PrivateKeyAlgorithmIdentifier ::= AlgorithmIdentifier */ typedef AlgorithmIdentifier PKCS8PrivateKeyAlgorithmIdentifier; ASN1EXP int ASN1CALL decode_PKCS8PrivateKeyAlgorithmIdentifier(const unsigned char *, size_t, PKCS8PrivateKeyAlgorithmIdentifier *, size_t *); ASN1EXP int ASN1CALL encode_PKCS8PrivateKeyAlgorithmIdentifier(unsigned char *, size_t, const PKCS8PrivateKeyAlgorithmIdentifier *, size_t *); ASN1EXP size_t ASN1CALL length_PKCS8PrivateKeyAlgorithmIdentifier(const PKCS8PrivateKeyAlgorithmIdentifier *); ASN1EXP int ASN1CALL copy_PKCS8PrivateKeyAlgorithmIdentifier (const PKCS8PrivateKeyAlgorithmIdentifier *, PKCS8PrivateKeyAlgorithmIdentifier *); ASN1EXP void ASN1CALL free_PKCS8PrivateKeyAlgorithmIdentifier (PKCS8PrivateKeyAlgorithmIdentifier *); /* PKCS8PrivateKey ::= OCTET STRING */ typedef heim_octet_string PKCS8PrivateKey; ASN1EXP int ASN1CALL decode_PKCS8PrivateKey(const unsigned char *, size_t, PKCS8PrivateKey *, size_t *); ASN1EXP int ASN1CALL encode_PKCS8PrivateKey(unsigned char *, size_t, const PKCS8PrivateKey *, size_t *); ASN1EXP size_t ASN1CALL length_PKCS8PrivateKey(const PKCS8PrivateKey *); ASN1EXP int ASN1CALL copy_PKCS8PrivateKey (const PKCS8PrivateKey *, PKCS8PrivateKey *); ASN1EXP void ASN1CALL free_PKCS8PrivateKey (PKCS8PrivateKey *); /* PKCS8Attributes ::= SET OF Attribute */ typedef struct PKCS8Attributes { unsigned int len; Attribute *val; } PKCS8Attributes; ASN1EXP int ASN1CALL decode_PKCS8Attributes(const unsigned char *, size_t, PKCS8Attributes *, size_t *); ASN1EXP int ASN1CALL encode_PKCS8Attributes(unsigned char *, size_t, const PKCS8Attributes *, size_t *); ASN1EXP size_t ASN1CALL length_PKCS8Attributes(const PKCS8Attributes *); ASN1EXP int ASN1CALL copy_PKCS8Attributes (const PKCS8Attributes *, PKCS8Attributes *); ASN1EXP void ASN1CALL free_PKCS8Attributes (PKCS8Attributes *); /* PKCS8PrivateKeyInfo ::= SEQUENCE { version INTEGER, privateKeyAlgorithm PKCS8PrivateKeyAlgorithmIdentifier, privateKey PKCS8PrivateKey, attributes [0] IMPLICIT SET OF Attribute OPTIONAL, } */ typedef struct PKCS8PrivateKeyInfo { heim_integer version; PKCS8PrivateKeyAlgorithmIdentifier privateKeyAlgorithm; PKCS8PrivateKey privateKey; struct PKCS8PrivateKeyInfo_attributes { unsigned int len; Attribute *val; } *attributes; } PKCS8PrivateKeyInfo; ASN1EXP int ASN1CALL decode_PKCS8PrivateKeyInfo(const unsigned char *, size_t, PKCS8PrivateKeyInfo *, size_t *); ASN1EXP int ASN1CALL encode_PKCS8PrivateKeyInfo(unsigned char *, size_t, const PKCS8PrivateKeyInfo *, size_t *); ASN1EXP size_t ASN1CALL length_PKCS8PrivateKeyInfo(const PKCS8PrivateKeyInfo *); ASN1EXP int ASN1CALL copy_PKCS8PrivateKeyInfo (const PKCS8PrivateKeyInfo *, PKCS8PrivateKeyInfo *); ASN1EXP void ASN1CALL free_PKCS8PrivateKeyInfo (PKCS8PrivateKeyInfo *); /* PKCS8EncryptedData ::= OCTET STRING */ typedef heim_octet_string PKCS8EncryptedData; ASN1EXP int ASN1CALL decode_PKCS8EncryptedData(const unsigned char *, size_t, PKCS8EncryptedData *, size_t *); ASN1EXP int ASN1CALL encode_PKCS8EncryptedData(unsigned char *, size_t, const PKCS8EncryptedData *, size_t *); ASN1EXP size_t ASN1CALL length_PKCS8EncryptedData(const PKCS8EncryptedData *); ASN1EXP int ASN1CALL copy_PKCS8EncryptedData (const PKCS8EncryptedData *, PKCS8EncryptedData *); ASN1EXP void ASN1CALL free_PKCS8EncryptedData (PKCS8EncryptedData *); /* PKCS8EncryptedPrivateKeyInfo ::= SEQUENCE { encryptionAlgorithm AlgorithmIdentifier, encryptedData PKCS8EncryptedData, } */ typedef struct PKCS8EncryptedPrivateKeyInfo { AlgorithmIdentifier encryptionAlgorithm; PKCS8EncryptedData encryptedData; } PKCS8EncryptedPrivateKeyInfo; ASN1EXP int ASN1CALL decode_PKCS8EncryptedPrivateKeyInfo(const unsigned char *, size_t, PKCS8EncryptedPrivateKeyInfo *, size_t *); ASN1EXP int ASN1CALL encode_PKCS8EncryptedPrivateKeyInfo(unsigned char *, size_t, const PKCS8EncryptedPrivateKeyInfo *, size_t *); ASN1EXP size_t ASN1CALL length_PKCS8EncryptedPrivateKeyInfo(const PKCS8EncryptedPrivateKeyInfo *); ASN1EXP int ASN1CALL copy_PKCS8EncryptedPrivateKeyInfo (const PKCS8EncryptedPrivateKeyInfo *, PKCS8EncryptedPrivateKeyInfo *); ASN1EXP void ASN1CALL free_PKCS8EncryptedPrivateKeyInfo (PKCS8EncryptedPrivateKeyInfo *); #endif /* __pkcs8_asn1_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/pkcs9_asn1.h000066400000000000000000000137711505521762700227510ustar00rootroot00000000000000/* Generated from ./pkcs9.asn1 */ /* Do not edit */ #ifndef __pkcs9_asn1_h__ #define __pkcs9_asn1_h__ #include #include #ifndef __asn1_common_definitions__ #define __asn1_common_definitions__ #ifndef __HEIM_BASE_DATA__ #define __HEIM_BASE_DATA__ 1 struct heim_base_data { size_t length; void *data; }; typedef struct heim_base_data heim_octet_string; #endif typedef struct heim_integer { size_t length; void *data; int negative; } heim_integer; typedef char *heim_general_string; typedef char *heim_utf8_string; typedef struct heim_base_data heim_printable_string; typedef struct heim_base_data heim_ia5_string; typedef struct heim_bmp_string { size_t length; uint16_t *data; } heim_bmp_string; typedef struct heim_universal_string { size_t length; uint32_t *data; } heim_universal_string; typedef char *heim_visible_string; typedef struct heim_oid { size_t length; unsigned *components; } heim_oid; typedef struct heim_bit_string { size_t length; void *data; } heim_bit_string; typedef struct heim_base_data heim_any; typedef struct heim_base_data heim_any_set; #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \ do { \ (BL) = length_##T((S)); \ (B) = malloc((BL)); \ if((B) == NULL) { \ (R) = ENOMEM; \ } else { \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (S), (L)); \ if((R) != 0) { \ free((B)); \ (B) = NULL; \ } \ } \ } while (0) #ifdef _WIN32 #ifndef ASN1_LIB #define ASN1EXP __declspec(dllimport) #else #define ASN1EXP #endif #define ASN1CALL __stdcall #else #define ASN1EXP #define ASN1CALL #endif struct units; #endif /* OBJECT IDENTIFIER id-pkcs-9 ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-9(9) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs_9; #define ASN1_OID_ID_PKCS_9 (&asn1_oid_id_pkcs_9) /* OBJECT IDENTIFIER id-pkcs9-emailAddress ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs9_emailAddress; #define ASN1_OID_ID_PKCS9_EMAILADDRESS (&asn1_oid_id_pkcs9_emailAddress) /* OBJECT IDENTIFIER id-pkcs9-contentType ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(3) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs9_contentType; #define ASN1_OID_ID_PKCS9_CONTENTTYPE (&asn1_oid_id_pkcs9_contentType) /* OBJECT IDENTIFIER id-pkcs9-messageDigest ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(4) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs9_messageDigest; #define ASN1_OID_ID_PKCS9_MESSAGEDIGEST (&asn1_oid_id_pkcs9_messageDigest) /* OBJECT IDENTIFIER id-pkcs9-signingTime ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(5) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs9_signingTime; #define ASN1_OID_ID_PKCS9_SIGNINGTIME (&asn1_oid_id_pkcs9_signingTime) /* OBJECT IDENTIFIER id-pkcs9-countersignature ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(6) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs9_countersignature; #define ASN1_OID_ID_PKCS9_COUNTERSIGNATURE (&asn1_oid_id_pkcs9_countersignature) /* OBJECT IDENTIFIER id-pkcs-9-at-friendlyName ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(20) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs_9_at_friendlyName; #define ASN1_OID_ID_PKCS_9_AT_FRIENDLYNAME (&asn1_oid_id_pkcs_9_at_friendlyName) /* OBJECT IDENTIFIER id-pkcs-9-at-localKeyId ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(21) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs_9_at_localKeyId; #define ASN1_OID_ID_PKCS_9_AT_LOCALKEYID (&asn1_oid_id_pkcs_9_at_localKeyId) /* OBJECT IDENTIFIER id-pkcs-9-at-certTypes ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(22) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs_9_at_certTypes; #define ASN1_OID_ID_PKCS_9_AT_CERTTYPES (&asn1_oid_id_pkcs_9_at_certTypes) /* OBJECT IDENTIFIER id-pkcs-9-at-certTypes-x509 ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs-9(9) label-less(22) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs_9_at_certTypes_x509; #define ASN1_OID_ID_PKCS_9_AT_CERTTYPES_X509 (&asn1_oid_id_pkcs_9_at_certTypes_x509) /* PKCS9-BMPString ::= BMPString */ typedef heim_bmp_string PKCS9_BMPString; ASN1EXP int ASN1CALL decode_PKCS9_BMPString(const unsigned char *, size_t, PKCS9_BMPString *, size_t *); ASN1EXP int ASN1CALL encode_PKCS9_BMPString(unsigned char *, size_t, const PKCS9_BMPString *, size_t *); ASN1EXP size_t ASN1CALL length_PKCS9_BMPString(const PKCS9_BMPString *); ASN1EXP int ASN1CALL copy_PKCS9_BMPString (const PKCS9_BMPString *, PKCS9_BMPString *); ASN1EXP void ASN1CALL free_PKCS9_BMPString (PKCS9_BMPString *); /* PKCS9-friendlyName ::= SET OF PKCS9-BMPString */ typedef struct PKCS9_friendlyName { unsigned int len; PKCS9_BMPString *val; } PKCS9_friendlyName; ASN1EXP int ASN1CALL decode_PKCS9_friendlyName(const unsigned char *, size_t, PKCS9_friendlyName *, size_t *); ASN1EXP int ASN1CALL encode_PKCS9_friendlyName(unsigned char *, size_t, const PKCS9_friendlyName *, size_t *); ASN1EXP size_t ASN1CALL length_PKCS9_friendlyName(const PKCS9_friendlyName *); ASN1EXP int ASN1CALL copy_PKCS9_friendlyName (const PKCS9_friendlyName *, PKCS9_friendlyName *); ASN1EXP void ASN1CALL free_PKCS9_friendlyName (PKCS9_friendlyName *); #endif /* __pkcs9_asn1_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/pkinit_asn1.h000066400000000000000000000657161505521762700232240ustar00rootroot00000000000000/* Generated from ./pkinit.asn1 */ /* Do not edit */ #ifndef __pkinit_asn1_h__ #define __pkinit_asn1_h__ #include #include #ifndef __asn1_common_definitions__ #define __asn1_common_definitions__ #ifndef __HEIM_BASE_DATA__ #define __HEIM_BASE_DATA__ 1 struct heim_base_data { size_t length; void *data; }; typedef struct heim_base_data heim_octet_string; #endif typedef struct heim_integer { size_t length; void *data; int negative; } heim_integer; typedef char *heim_general_string; typedef char *heim_utf8_string; typedef struct heim_base_data heim_printable_string; typedef struct heim_base_data heim_ia5_string; typedef struct heim_bmp_string { size_t length; uint16_t *data; } heim_bmp_string; typedef struct heim_universal_string { size_t length; uint32_t *data; } heim_universal_string; typedef char *heim_visible_string; typedef struct heim_oid { size_t length; unsigned *components; } heim_oid; typedef struct heim_bit_string { size_t length; void *data; } heim_bit_string; typedef struct heim_base_data heim_any; typedef struct heim_base_data heim_any_set; #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \ do { \ (BL) = length_##T((S)); \ (B) = malloc((BL)); \ if((B) == NULL) { \ (R) = ENOMEM; \ } else { \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (S), (L)); \ if((R) != 0) { \ free((B)); \ (B) = NULL; \ } \ } \ } while (0) #ifdef _WIN32 #ifndef ASN1_LIB #define ASN1EXP __declspec(dllimport) #else #define ASN1EXP #endif #define ASN1CALL __stdcall #else #define ASN1EXP #define ASN1CALL #endif struct units; #endif #include #include #include #include /* OBJECT IDENTIFIER id-pkinit ::= { iso(1) org(3) dod(6) internet(1) security(5) kerberosv5(2) pkinit(3) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkinit; #define ASN1_OID_ID_PKINIT (&asn1_oid_id_pkinit) /* OBJECT IDENTIFIER id-pkauthdata ::= { iso(1) org(3) dod(6) internet(1) security(5) kerberosv5(2) pkinit(3) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkauthdata; #define ASN1_OID_ID_PKAUTHDATA (&asn1_oid_id_pkauthdata) /* OBJECT IDENTIFIER id-pkdhkeydata ::= { iso(1) org(3) dod(6) internet(1) security(5) kerberosv5(2) pkinit(3) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkdhkeydata; #define ASN1_OID_ID_PKDHKEYDATA (&asn1_oid_id_pkdhkeydata) /* OBJECT IDENTIFIER id-pkrkeydata ::= { iso(1) org(3) dod(6) internet(1) security(5) kerberosv5(2) pkinit(3) label-less(3) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkrkeydata; #define ASN1_OID_ID_PKRKEYDATA (&asn1_oid_id_pkrkeydata) /* OBJECT IDENTIFIER id-pkekuoid ::= { iso(1) org(3) dod(6) internet(1) security(5) kerberosv5(2) pkinit(3) label-less(4) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkekuoid; #define ASN1_OID_ID_PKEKUOID (&asn1_oid_id_pkekuoid) /* OBJECT IDENTIFIER id-pkkdcekuoid ::= { iso(1) org(3) dod(6) internet(1) security(5) kerberosv5(2) pkinit(3) label-less(5) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkkdcekuoid; #define ASN1_OID_ID_PKKDCEKUOID (&asn1_oid_id_pkkdcekuoid) /* OBJECT IDENTIFIER id-apple-system-id ::= { label-less(1) label-less(2) label-less(840) label-less(113635) label-less(100) label-less(4) label-less(4) } */ extern ASN1EXP const heim_oid asn1_oid_id_apple_system_id; #define ASN1_OID_ID_APPLE_SYSTEM_ID (&asn1_oid_id_apple_system_id) /* OBJECT IDENTIFIER id-pkinit-kdf ::= { iso(1) org(3) dod(6) internet(1) security(5) kerberosv5(2) pkinit(3) label-less(6) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkinit_kdf; #define ASN1_OID_ID_PKINIT_KDF (&asn1_oid_id_pkinit_kdf) /* OBJECT IDENTIFIER id-pkinit-kdf-ah-sha1 ::= { iso(1) org(3) dod(6) internet(1) security(5) kerberosv5(2) pkinit(3) label-less(6) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkinit_kdf_ah_sha1; #define ASN1_OID_ID_PKINIT_KDF_AH_SHA1 (&asn1_oid_id_pkinit_kdf_ah_sha1) /* OBJECT IDENTIFIER id-pkinit-kdf-ah-sha256 ::= { iso(1) org(3) dod(6) internet(1) security(5) kerberosv5(2) pkinit(3) label-less(6) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkinit_kdf_ah_sha256; #define ASN1_OID_ID_PKINIT_KDF_AH_SHA256 (&asn1_oid_id_pkinit_kdf_ah_sha256) /* OBJECT IDENTIFIER id-pkinit-kdf-ah-sha512 ::= { iso(1) org(3) dod(6) internet(1) security(5) kerberosv5(2) pkinit(3) label-less(6) label-less(3) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkinit_kdf_ah_sha512; #define ASN1_OID_ID_PKINIT_KDF_AH_SHA512 (&asn1_oid_id_pkinit_kdf_ah_sha512) /* OBJECT IDENTIFIER id-pkinit-san ::= { iso(1) org(3) dod(6) internet(1) security(5) kerberosv5(2) x509-sanan(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkinit_san; #define ASN1_OID_ID_PKINIT_SAN (&asn1_oid_id_pkinit_san) /* OBJECT IDENTIFIER id-pkinit-ms-eku ::= { iso(1) org(3) dod(6) internet(1) private(4) enterprise(1) microsoft(311) label-less(20) label-less(2) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkinit_ms_eku; #define ASN1_OID_ID_PKINIT_MS_EKU (&asn1_oid_id_pkinit_ms_eku) /* OBJECT IDENTIFIER id-pkinit-ms-san ::= { iso(1) org(3) dod(6) internet(1) private(4) enterprise(1) microsoft(311) label-less(20) label-less(2) label-less(3) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkinit_ms_san; #define ASN1_OID_ID_PKINIT_MS_SAN (&asn1_oid_id_pkinit_ms_san) /* MS-UPN-SAN ::= UTF8String */ typedef heim_utf8_string MS_UPN_SAN; ASN1EXP int ASN1CALL decode_MS_UPN_SAN(const unsigned char *, size_t, MS_UPN_SAN *, size_t *); ASN1EXP int ASN1CALL encode_MS_UPN_SAN(unsigned char *, size_t, const MS_UPN_SAN *, size_t *); ASN1EXP size_t ASN1CALL length_MS_UPN_SAN(const MS_UPN_SAN *); ASN1EXP int ASN1CALL copy_MS_UPN_SAN (const MS_UPN_SAN *, MS_UPN_SAN *); ASN1EXP void ASN1CALL free_MS_UPN_SAN (MS_UPN_SAN *); enum { pa_pk_as_req = 16 }; enum { pa_pk_as_rep = 17 }; enum { td_trusted_certifiers = 104 }; enum { td_invalid_certificates = 105 }; enum { td_dh_parameters = 109 }; /* DHNonce ::= OCTET STRING */ typedef heim_octet_string DHNonce; ASN1EXP int ASN1CALL decode_DHNonce(const unsigned char *, size_t, DHNonce *, size_t *); ASN1EXP int ASN1CALL encode_DHNonce(unsigned char *, size_t, const DHNonce *, size_t *); ASN1EXP size_t ASN1CALL length_DHNonce(const DHNonce *); ASN1EXP int ASN1CALL copy_DHNonce (const DHNonce *, DHNonce *); ASN1EXP void ASN1CALL free_DHNonce (DHNonce *); /* KDFAlgorithmId ::= SEQUENCE { kdf-id [0] OBJECT IDENTIFIER, ..., } */ typedef struct KDFAlgorithmId { heim_oid kdf_id; } KDFAlgorithmId; ASN1EXP int ASN1CALL decode_KDFAlgorithmId(const unsigned char *, size_t, KDFAlgorithmId *, size_t *); ASN1EXP int ASN1CALL encode_KDFAlgorithmId(unsigned char *, size_t, const KDFAlgorithmId *, size_t *); ASN1EXP size_t ASN1CALL length_KDFAlgorithmId(const KDFAlgorithmId *); ASN1EXP int ASN1CALL copy_KDFAlgorithmId (const KDFAlgorithmId *, KDFAlgorithmId *); ASN1EXP void ASN1CALL free_KDFAlgorithmId (KDFAlgorithmId *); /* TrustedCA ::= SEQUENCE { caName [0] IMPLICIT OCTET STRING, certificateSerialNumber [1] INTEGER OPTIONAL, subjectKeyIdentifier [2] OCTET STRING OPTIONAL, ..., } */ typedef struct TrustedCA { heim_octet_string caName; heim_integer *certificateSerialNumber; heim_octet_string *subjectKeyIdentifier; } TrustedCA; ASN1EXP int ASN1CALL decode_TrustedCA(const unsigned char *, size_t, TrustedCA *, size_t *); ASN1EXP int ASN1CALL encode_TrustedCA(unsigned char *, size_t, const TrustedCA *, size_t *); ASN1EXP size_t ASN1CALL length_TrustedCA(const TrustedCA *); ASN1EXP int ASN1CALL copy_TrustedCA (const TrustedCA *, TrustedCA *); ASN1EXP void ASN1CALL free_TrustedCA (TrustedCA *); /* ExternalPrincipalIdentifier ::= SEQUENCE { subjectName [0] IMPLICIT OCTET STRING OPTIONAL, issuerAndSerialNumber [1] IMPLICIT OCTET STRING OPTIONAL, subjectKeyIdentifier [2] IMPLICIT OCTET STRING OPTIONAL, ..., } */ typedef struct ExternalPrincipalIdentifier { heim_octet_string *subjectName; heim_octet_string *issuerAndSerialNumber; heim_octet_string *subjectKeyIdentifier; } ExternalPrincipalIdentifier; ASN1EXP int ASN1CALL decode_ExternalPrincipalIdentifier(const unsigned char *, size_t, ExternalPrincipalIdentifier *, size_t *); ASN1EXP int ASN1CALL encode_ExternalPrincipalIdentifier(unsigned char *, size_t, const ExternalPrincipalIdentifier *, size_t *); ASN1EXP size_t ASN1CALL length_ExternalPrincipalIdentifier(const ExternalPrincipalIdentifier *); ASN1EXP int ASN1CALL copy_ExternalPrincipalIdentifier (const ExternalPrincipalIdentifier *, ExternalPrincipalIdentifier *); ASN1EXP void ASN1CALL free_ExternalPrincipalIdentifier (ExternalPrincipalIdentifier *); /* ExternalPrincipalIdentifiers ::= SEQUENCE OF ExternalPrincipalIdentifier */ typedef struct ExternalPrincipalIdentifiers { unsigned int len; ExternalPrincipalIdentifier *val; } ExternalPrincipalIdentifiers; ASN1EXP int ASN1CALL decode_ExternalPrincipalIdentifiers(const unsigned char *, size_t, ExternalPrincipalIdentifiers *, size_t *); ASN1EXP int ASN1CALL encode_ExternalPrincipalIdentifiers(unsigned char *, size_t, const ExternalPrincipalIdentifiers *, size_t *); ASN1EXP size_t ASN1CALL length_ExternalPrincipalIdentifiers(const ExternalPrincipalIdentifiers *); ASN1EXP int ASN1CALL copy_ExternalPrincipalIdentifiers (const ExternalPrincipalIdentifiers *, ExternalPrincipalIdentifiers *); ASN1EXP void ASN1CALL free_ExternalPrincipalIdentifiers (ExternalPrincipalIdentifiers *); /* PA-PK-AS-REQ ::= SEQUENCE { signedAuthPack [0] IMPLICIT OCTET STRING, trustedCertifiers [1] ExternalPrincipalIdentifiers OPTIONAL, kdcPkId [2] IMPLICIT OCTET STRING OPTIONAL, ..., } */ typedef struct PA_PK_AS_REQ { heim_octet_string signedAuthPack; ExternalPrincipalIdentifiers *trustedCertifiers; heim_octet_string *kdcPkId; } PA_PK_AS_REQ; ASN1EXP int ASN1CALL decode_PA_PK_AS_REQ(const unsigned char *, size_t, PA_PK_AS_REQ *, size_t *); ASN1EXP int ASN1CALL encode_PA_PK_AS_REQ(unsigned char *, size_t, const PA_PK_AS_REQ *, size_t *); ASN1EXP size_t ASN1CALL length_PA_PK_AS_REQ(const PA_PK_AS_REQ *); ASN1EXP int ASN1CALL copy_PA_PK_AS_REQ (const PA_PK_AS_REQ *, PA_PK_AS_REQ *); ASN1EXP void ASN1CALL free_PA_PK_AS_REQ (PA_PK_AS_REQ *); /* PKAuthenticator ::= SEQUENCE { cusec [0] INTEGER, ctime [1] KerberosTime, nonce [2] INTEGER (0..4294967295), paChecksum [3] OCTET STRING OPTIONAL, ..., } */ typedef struct PKAuthenticator { heim_integer cusec; KerberosTime ctime; unsigned int nonce; heim_octet_string *paChecksum; } PKAuthenticator; ASN1EXP int ASN1CALL decode_PKAuthenticator(const unsigned char *, size_t, PKAuthenticator *, size_t *); ASN1EXP int ASN1CALL encode_PKAuthenticator(unsigned char *, size_t, const PKAuthenticator *, size_t *); ASN1EXP size_t ASN1CALL length_PKAuthenticator(const PKAuthenticator *); ASN1EXP int ASN1CALL copy_PKAuthenticator (const PKAuthenticator *, PKAuthenticator *); ASN1EXP void ASN1CALL free_PKAuthenticator (PKAuthenticator *); /* AuthPack ::= SEQUENCE { pkAuthenticator [0] PKAuthenticator, clientPublicValue [1] SubjectPublicKeyInfo OPTIONAL, supportedCMSTypes [2] SEQUENCE OF AlgorithmIdentifier OPTIONAL, clientDHNonce [3] DHNonce OPTIONAL, ..., supportedKDFs [4] SEQUENCE OF KDFAlgorithmId OPTIONAL, ..., } */ typedef struct AuthPack { PKAuthenticator pkAuthenticator; SubjectPublicKeyInfo *clientPublicValue; struct AuthPack_supportedCMSTypes { unsigned int len; AlgorithmIdentifier *val; } *supportedCMSTypes; DHNonce *clientDHNonce; struct AuthPack_supportedKDFs { unsigned int len; KDFAlgorithmId *val; } *supportedKDFs; } AuthPack; ASN1EXP int ASN1CALL decode_AuthPack(const unsigned char *, size_t, AuthPack *, size_t *); ASN1EXP int ASN1CALL encode_AuthPack(unsigned char *, size_t, const AuthPack *, size_t *); ASN1EXP size_t ASN1CALL length_AuthPack(const AuthPack *); ASN1EXP int ASN1CALL copy_AuthPack (const AuthPack *, AuthPack *); ASN1EXP void ASN1CALL free_AuthPack (AuthPack *); /* TD-TRUSTED-CERTIFIERS ::= ExternalPrincipalIdentifiers */ typedef ExternalPrincipalIdentifiers TD_TRUSTED_CERTIFIERS; ASN1EXP int ASN1CALL decode_TD_TRUSTED_CERTIFIERS(const unsigned char *, size_t, TD_TRUSTED_CERTIFIERS *, size_t *); ASN1EXP int ASN1CALL encode_TD_TRUSTED_CERTIFIERS(unsigned char *, size_t, const TD_TRUSTED_CERTIFIERS *, size_t *); ASN1EXP size_t ASN1CALL length_TD_TRUSTED_CERTIFIERS(const TD_TRUSTED_CERTIFIERS *); ASN1EXP int ASN1CALL copy_TD_TRUSTED_CERTIFIERS (const TD_TRUSTED_CERTIFIERS *, TD_TRUSTED_CERTIFIERS *); ASN1EXP void ASN1CALL free_TD_TRUSTED_CERTIFIERS (TD_TRUSTED_CERTIFIERS *); /* TD-INVALID-CERTIFICATES ::= ExternalPrincipalIdentifiers */ typedef ExternalPrincipalIdentifiers TD_INVALID_CERTIFICATES; ASN1EXP int ASN1CALL decode_TD_INVALID_CERTIFICATES(const unsigned char *, size_t, TD_INVALID_CERTIFICATES *, size_t *); ASN1EXP int ASN1CALL encode_TD_INVALID_CERTIFICATES(unsigned char *, size_t, const TD_INVALID_CERTIFICATES *, size_t *); ASN1EXP size_t ASN1CALL length_TD_INVALID_CERTIFICATES(const TD_INVALID_CERTIFICATES *); ASN1EXP int ASN1CALL copy_TD_INVALID_CERTIFICATES (const TD_INVALID_CERTIFICATES *, TD_INVALID_CERTIFICATES *); ASN1EXP void ASN1CALL free_TD_INVALID_CERTIFICATES (TD_INVALID_CERTIFICATES *); /* KRB5PrincipalName ::= SEQUENCE { realm [0] Realm, principalName [1] PrincipalName, } */ typedef struct KRB5PrincipalName { Realm realm; PrincipalName principalName; } KRB5PrincipalName; ASN1EXP int ASN1CALL decode_KRB5PrincipalName(const unsigned char *, size_t, KRB5PrincipalName *, size_t *); ASN1EXP int ASN1CALL encode_KRB5PrincipalName(unsigned char *, size_t, const KRB5PrincipalName *, size_t *); ASN1EXP size_t ASN1CALL length_KRB5PrincipalName(const KRB5PrincipalName *); ASN1EXP int ASN1CALL copy_KRB5PrincipalName (const KRB5PrincipalName *, KRB5PrincipalName *); ASN1EXP void ASN1CALL free_KRB5PrincipalName (KRB5PrincipalName *); /* AD-INITIAL-VERIFIED-CAS ::= SEQUENCE OF ExternalPrincipalIdentifier */ typedef struct AD_INITIAL_VERIFIED_CAS { unsigned int len; ExternalPrincipalIdentifier *val; } AD_INITIAL_VERIFIED_CAS; ASN1EXP int ASN1CALL decode_AD_INITIAL_VERIFIED_CAS(const unsigned char *, size_t, AD_INITIAL_VERIFIED_CAS *, size_t *); ASN1EXP int ASN1CALL encode_AD_INITIAL_VERIFIED_CAS(unsigned char *, size_t, const AD_INITIAL_VERIFIED_CAS *, size_t *); ASN1EXP size_t ASN1CALL length_AD_INITIAL_VERIFIED_CAS(const AD_INITIAL_VERIFIED_CAS *); ASN1EXP int ASN1CALL copy_AD_INITIAL_VERIFIED_CAS (const AD_INITIAL_VERIFIED_CAS *, AD_INITIAL_VERIFIED_CAS *); ASN1EXP void ASN1CALL free_AD_INITIAL_VERIFIED_CAS (AD_INITIAL_VERIFIED_CAS *); /* DHRepInfo ::= SEQUENCE { dhSignedData [0] IMPLICIT OCTET STRING, serverDHNonce [1] DHNonce OPTIONAL, ..., kdf [2] KDFAlgorithmId OPTIONAL, ..., } */ typedef struct DHRepInfo { heim_octet_string dhSignedData; DHNonce *serverDHNonce; KDFAlgorithmId *kdf; } DHRepInfo; ASN1EXP int ASN1CALL decode_DHRepInfo(const unsigned char *, size_t, DHRepInfo *, size_t *); ASN1EXP int ASN1CALL encode_DHRepInfo(unsigned char *, size_t, const DHRepInfo *, size_t *); ASN1EXP size_t ASN1CALL length_DHRepInfo(const DHRepInfo *); ASN1EXP int ASN1CALL copy_DHRepInfo (const DHRepInfo *, DHRepInfo *); ASN1EXP void ASN1CALL free_DHRepInfo (DHRepInfo *); /* PA-PK-AS-REP ::= CHOICE { dhInfo [0] DHRepInfo, encKeyPack [1] IMPLICIT OCTET STRING, ..., } */ typedef struct PA_PK_AS_REP { enum PA_PK_AS_REP_enum { choice_PA_PK_AS_REP_asn1_ellipsis = 0, choice_PA_PK_AS_REP_dhInfo, choice_PA_PK_AS_REP_encKeyPack /* ... */ } element; union { DHRepInfo dhInfo; heim_octet_string encKeyPack; heim_octet_string asn1_ellipsis; } u; } PA_PK_AS_REP; ASN1EXP int ASN1CALL decode_PA_PK_AS_REP(const unsigned char *, size_t, PA_PK_AS_REP *, size_t *); ASN1EXP int ASN1CALL encode_PA_PK_AS_REP(unsigned char *, size_t, const PA_PK_AS_REP *, size_t *); ASN1EXP size_t ASN1CALL length_PA_PK_AS_REP(const PA_PK_AS_REP *); ASN1EXP int ASN1CALL copy_PA_PK_AS_REP (const PA_PK_AS_REP *, PA_PK_AS_REP *); ASN1EXP void ASN1CALL free_PA_PK_AS_REP (PA_PK_AS_REP *); /* KDCDHKeyInfo ::= SEQUENCE { subjectPublicKey [0] BIT STRING { }, nonce [1] INTEGER (0..4294967295), dhKeyExpiration [2] KerberosTime OPTIONAL, ..., } */ typedef struct KDCDHKeyInfo { heim_bit_string subjectPublicKey; unsigned int nonce; KerberosTime *dhKeyExpiration; } KDCDHKeyInfo; ASN1EXP int ASN1CALL decode_KDCDHKeyInfo(const unsigned char *, size_t, KDCDHKeyInfo *, size_t *); ASN1EXP int ASN1CALL encode_KDCDHKeyInfo(unsigned char *, size_t, const KDCDHKeyInfo *, size_t *); ASN1EXP size_t ASN1CALL length_KDCDHKeyInfo(const KDCDHKeyInfo *); ASN1EXP int ASN1CALL copy_KDCDHKeyInfo (const KDCDHKeyInfo *, KDCDHKeyInfo *); ASN1EXP void ASN1CALL free_KDCDHKeyInfo (KDCDHKeyInfo *); /* ReplyKeyPack ::= SEQUENCE { replyKey [0] EncryptionKey, asChecksum [1] Checksum, ..., } */ typedef struct ReplyKeyPack { EncryptionKey replyKey; Checksum asChecksum; } ReplyKeyPack; ASN1EXP int ASN1CALL decode_ReplyKeyPack(const unsigned char *, size_t, ReplyKeyPack *, size_t *); ASN1EXP int ASN1CALL encode_ReplyKeyPack(unsigned char *, size_t, const ReplyKeyPack *, size_t *); ASN1EXP size_t ASN1CALL length_ReplyKeyPack(const ReplyKeyPack *); ASN1EXP int ASN1CALL copy_ReplyKeyPack (const ReplyKeyPack *, ReplyKeyPack *); ASN1EXP void ASN1CALL free_ReplyKeyPack (ReplyKeyPack *); /* TD-DH-PARAMETERS ::= SEQUENCE OF AlgorithmIdentifier */ typedef struct TD_DH_PARAMETERS { unsigned int len; AlgorithmIdentifier *val; } TD_DH_PARAMETERS; ASN1EXP int ASN1CALL decode_TD_DH_PARAMETERS(const unsigned char *, size_t, TD_DH_PARAMETERS *, size_t *); ASN1EXP int ASN1CALL encode_TD_DH_PARAMETERS(unsigned char *, size_t, const TD_DH_PARAMETERS *, size_t *); ASN1EXP size_t ASN1CALL length_TD_DH_PARAMETERS(const TD_DH_PARAMETERS *); ASN1EXP int ASN1CALL copy_TD_DH_PARAMETERS (const TD_DH_PARAMETERS *, TD_DH_PARAMETERS *); ASN1EXP void ASN1CALL free_TD_DH_PARAMETERS (TD_DH_PARAMETERS *); /* PKAuthenticator-Win2k ::= SEQUENCE { kdcName [0] PrincipalName, kdcRealm [1] Realm, cusec [2] INTEGER (0..4294967295), ctime [3] KerberosTime, nonce [4] INTEGER (-2147483648..2147483647), } */ typedef struct PKAuthenticator_Win2k { PrincipalName kdcName; Realm kdcRealm; unsigned int cusec; KerberosTime ctime; int nonce; } PKAuthenticator_Win2k; ASN1EXP int ASN1CALL decode_PKAuthenticator_Win2k(const unsigned char *, size_t, PKAuthenticator_Win2k *, size_t *); ASN1EXP int ASN1CALL encode_PKAuthenticator_Win2k(unsigned char *, size_t, const PKAuthenticator_Win2k *, size_t *); ASN1EXP size_t ASN1CALL length_PKAuthenticator_Win2k(const PKAuthenticator_Win2k *); ASN1EXP int ASN1CALL copy_PKAuthenticator_Win2k (const PKAuthenticator_Win2k *, PKAuthenticator_Win2k *); ASN1EXP void ASN1CALL free_PKAuthenticator_Win2k (PKAuthenticator_Win2k *); /* AuthPack-Win2k ::= SEQUENCE { pkAuthenticator [0] PKAuthenticator-Win2k, clientPublicValue [1] SubjectPublicKeyInfo OPTIONAL, } */ typedef struct AuthPack_Win2k { PKAuthenticator_Win2k pkAuthenticator; SubjectPublicKeyInfo *clientPublicValue; } AuthPack_Win2k; ASN1EXP int ASN1CALL decode_AuthPack_Win2k(const unsigned char *, size_t, AuthPack_Win2k *, size_t *); ASN1EXP int ASN1CALL encode_AuthPack_Win2k(unsigned char *, size_t, const AuthPack_Win2k *, size_t *); ASN1EXP size_t ASN1CALL length_AuthPack_Win2k(const AuthPack_Win2k *); ASN1EXP int ASN1CALL copy_AuthPack_Win2k (const AuthPack_Win2k *, AuthPack_Win2k *); ASN1EXP void ASN1CALL free_AuthPack_Win2k (AuthPack_Win2k *); /* TrustedCA-Win2k ::= CHOICE { caName [1] heim_any, issuerAndSerial [2] IssuerAndSerialNumber, } */ typedef struct TrustedCA_Win2k { enum TrustedCA_Win2k_enum { choice_TrustedCA_Win2k_caName = 1, choice_TrustedCA_Win2k_issuerAndSerial } element; union { heim_any caName; IssuerAndSerialNumber issuerAndSerial; } u; } TrustedCA_Win2k; ASN1EXP int ASN1CALL decode_TrustedCA_Win2k(const unsigned char *, size_t, TrustedCA_Win2k *, size_t *); ASN1EXP int ASN1CALL encode_TrustedCA_Win2k(unsigned char *, size_t, const TrustedCA_Win2k *, size_t *); ASN1EXP size_t ASN1CALL length_TrustedCA_Win2k(const TrustedCA_Win2k *); ASN1EXP int ASN1CALL copy_TrustedCA_Win2k (const TrustedCA_Win2k *, TrustedCA_Win2k *); ASN1EXP void ASN1CALL free_TrustedCA_Win2k (TrustedCA_Win2k *); /* PA-PK-AS-REQ-Win2k ::= SEQUENCE { signed-auth-pack [0] IMPLICIT OCTET STRING, trusted-certifiers [2] SEQUENCE OF TrustedCA-Win2k OPTIONAL, kdc-cert [3] IMPLICIT OCTET STRING OPTIONAL, encryption-cert [4] IMPLICIT OCTET STRING OPTIONAL, } */ typedef struct PA_PK_AS_REQ_Win2k { heim_octet_string signed_auth_pack; struct PA_PK_AS_REQ_Win2k_trusted_certifiers { unsigned int len; TrustedCA_Win2k *val; } *trusted_certifiers; heim_octet_string *kdc_cert; heim_octet_string *encryption_cert; } PA_PK_AS_REQ_Win2k; ASN1EXP int ASN1CALL decode_PA_PK_AS_REQ_Win2k(const unsigned char *, size_t, PA_PK_AS_REQ_Win2k *, size_t *); ASN1EXP int ASN1CALL encode_PA_PK_AS_REQ_Win2k(unsigned char *, size_t, const PA_PK_AS_REQ_Win2k *, size_t *); ASN1EXP size_t ASN1CALL length_PA_PK_AS_REQ_Win2k(const PA_PK_AS_REQ_Win2k *); ASN1EXP int ASN1CALL copy_PA_PK_AS_REQ_Win2k (const PA_PK_AS_REQ_Win2k *, PA_PK_AS_REQ_Win2k *); ASN1EXP void ASN1CALL free_PA_PK_AS_REQ_Win2k (PA_PK_AS_REQ_Win2k *); /* PA-PK-AS-REP-Win2k ::= CHOICE { dhSignedData [0] IMPLICIT OCTET STRING, encKeyPack [1] IMPLICIT OCTET STRING, } */ typedef struct PA_PK_AS_REP_Win2k { enum PA_PK_AS_REP_Win2k_enum { choice_PA_PK_AS_REP_Win2k_dhSignedData = 1, choice_PA_PK_AS_REP_Win2k_encKeyPack } element; union { heim_octet_string dhSignedData; heim_octet_string encKeyPack; } u; } PA_PK_AS_REP_Win2k; ASN1EXP int ASN1CALL decode_PA_PK_AS_REP_Win2k(const unsigned char *, size_t, PA_PK_AS_REP_Win2k *, size_t *); ASN1EXP int ASN1CALL encode_PA_PK_AS_REP_Win2k(unsigned char *, size_t, const PA_PK_AS_REP_Win2k *, size_t *); ASN1EXP size_t ASN1CALL length_PA_PK_AS_REP_Win2k(const PA_PK_AS_REP_Win2k *); ASN1EXP int ASN1CALL copy_PA_PK_AS_REP_Win2k (const PA_PK_AS_REP_Win2k *, PA_PK_AS_REP_Win2k *); ASN1EXP void ASN1CALL free_PA_PK_AS_REP_Win2k (PA_PK_AS_REP_Win2k *); /* KDCDHKeyInfo-Win2k ::= SEQUENCE { nonce [0] INTEGER (-2147483648..2147483647), subjectPublicKey [2] BIT STRING { }, } */ typedef struct KDCDHKeyInfo_Win2k { int nonce; heim_bit_string subjectPublicKey; } KDCDHKeyInfo_Win2k; ASN1EXP int ASN1CALL decode_KDCDHKeyInfo_Win2k(const unsigned char *, size_t, KDCDHKeyInfo_Win2k *, size_t *); ASN1EXP int ASN1CALL encode_KDCDHKeyInfo_Win2k(unsigned char *, size_t, const KDCDHKeyInfo_Win2k *, size_t *); ASN1EXP size_t ASN1CALL length_KDCDHKeyInfo_Win2k(const KDCDHKeyInfo_Win2k *); ASN1EXP int ASN1CALL copy_KDCDHKeyInfo_Win2k (const KDCDHKeyInfo_Win2k *, KDCDHKeyInfo_Win2k *); ASN1EXP void ASN1CALL free_KDCDHKeyInfo_Win2k (KDCDHKeyInfo_Win2k *); /* ReplyKeyPack-Win2k ::= SEQUENCE { replyKey [0] EncryptionKey, nonce [1] INTEGER (-2147483648..2147483647), ..., } */ typedef struct ReplyKeyPack_Win2k { EncryptionKey replyKey; int nonce; } ReplyKeyPack_Win2k; ASN1EXP int ASN1CALL decode_ReplyKeyPack_Win2k(const unsigned char *, size_t, ReplyKeyPack_Win2k *, size_t *); ASN1EXP int ASN1CALL encode_ReplyKeyPack_Win2k(unsigned char *, size_t, const ReplyKeyPack_Win2k *, size_t *); ASN1EXP size_t ASN1CALL length_ReplyKeyPack_Win2k(const ReplyKeyPack_Win2k *); ASN1EXP int ASN1CALL copy_ReplyKeyPack_Win2k (const ReplyKeyPack_Win2k *, ReplyKeyPack_Win2k *); ASN1EXP void ASN1CALL free_ReplyKeyPack_Win2k (ReplyKeyPack_Win2k *); /* PA-PK-AS-REP-BTMM ::= SEQUENCE { dhSignedData [0] heim_any OPTIONAL, encKeyPack [1] heim_any OPTIONAL, } */ typedef struct PA_PK_AS_REP_BTMM { heim_any *dhSignedData; heim_any *encKeyPack; } PA_PK_AS_REP_BTMM; ASN1EXP int ASN1CALL decode_PA_PK_AS_REP_BTMM(const unsigned char *, size_t, PA_PK_AS_REP_BTMM *, size_t *); ASN1EXP int ASN1CALL encode_PA_PK_AS_REP_BTMM(unsigned char *, size_t, const PA_PK_AS_REP_BTMM *, size_t *); ASN1EXP size_t ASN1CALL length_PA_PK_AS_REP_BTMM(const PA_PK_AS_REP_BTMM *); ASN1EXP int ASN1CALL copy_PA_PK_AS_REP_BTMM (const PA_PK_AS_REP_BTMM *, PA_PK_AS_REP_BTMM *); ASN1EXP void ASN1CALL free_PA_PK_AS_REP_BTMM (PA_PK_AS_REP_BTMM *); /* PkinitSP80056AOtherInfo ::= SEQUENCE { algorithmID AlgorithmIdentifier, partyUInfo [0] OCTET STRING, partyVInfo [1] OCTET STRING, suppPubInfo [2] OCTET STRING OPTIONAL, suppPrivInfo [3] OCTET STRING OPTIONAL, } */ typedef struct PkinitSP80056AOtherInfo { AlgorithmIdentifier algorithmID; heim_octet_string partyUInfo; heim_octet_string partyVInfo; heim_octet_string *suppPubInfo; heim_octet_string *suppPrivInfo; } PkinitSP80056AOtherInfo; ASN1EXP int ASN1CALL decode_PkinitSP80056AOtherInfo(const unsigned char *, size_t, PkinitSP80056AOtherInfo *, size_t *); ASN1EXP int ASN1CALL encode_PkinitSP80056AOtherInfo(unsigned char *, size_t, const PkinitSP80056AOtherInfo *, size_t *); ASN1EXP size_t ASN1CALL length_PkinitSP80056AOtherInfo(const PkinitSP80056AOtherInfo *); ASN1EXP int ASN1CALL copy_PkinitSP80056AOtherInfo (const PkinitSP80056AOtherInfo *, PkinitSP80056AOtherInfo *); ASN1EXP void ASN1CALL free_PkinitSP80056AOtherInfo (PkinitSP80056AOtherInfo *); /* PkinitSuppPubInfo ::= SEQUENCE { enctype [0] INTEGER (-2147483648..2147483647), as-REQ [1] OCTET STRING, pk-as-rep [2] OCTET STRING, ticket [3] Ticket, ..., } */ typedef struct PkinitSuppPubInfo { int enctype; heim_octet_string as_REQ; heim_octet_string pk_as_rep; Ticket ticket; } PkinitSuppPubInfo; ASN1EXP int ASN1CALL decode_PkinitSuppPubInfo(const unsigned char *, size_t, PkinitSuppPubInfo *, size_t *); ASN1EXP int ASN1CALL encode_PkinitSuppPubInfo(unsigned char *, size_t, const PkinitSuppPubInfo *, size_t *); ASN1EXP size_t ASN1CALL length_PkinitSuppPubInfo(const PkinitSuppPubInfo *); ASN1EXP int ASN1CALL copy_PkinitSuppPubInfo (const PkinitSuppPubInfo *, PkinitSuppPubInfo *); ASN1EXP void ASN1CALL free_PkinitSuppPubInfo (PkinitSuppPubInfo *); #endif /* __pkinit_asn1_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/resolve.h000066400000000000000000000164121505521762700224500ustar00rootroot00000000000000/* * Copyright (c) 1995 - 2002 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef __RESOLVE_H__ #define __RESOLVE_H__ #ifndef ROKEN_LIB_FUNCTION #ifdef _WIN32 #define ROKEN_LIB_FUNCTION #define ROKEN_LIB_CALL __cdecl #else #define ROKEN_LIB_FUNCTION #define ROKEN_LIB_CALL #endif #endif enum { rk_ns_c_in = 1 }; enum { rk_ns_t_invalid = 0, /* Cookie. */ rk_ns_t_a = 1, /* Host address. */ rk_ns_t_ns = 2, /* Authoritative server. */ rk_ns_t_md = 3, /* Mail destination. */ rk_ns_t_mf = 4, /* Mail forwarder. */ rk_ns_t_cname = 5, /* Canonical name. */ rk_ns_t_soa = 6, /* Start of authority zone. */ rk_ns_t_mb = 7, /* Mailbox domain name. */ rk_ns_t_mg = 8, /* Mail group member. */ rk_ns_t_mr = 9, /* Mail rename name. */ rk_ns_t_null = 10, /* Null resource record. */ rk_ns_t_wks = 11, /* Well known service. */ rk_ns_t_ptr = 12, /* Domain name pointer. */ rk_ns_t_hinfo = 13, /* Host information. */ rk_ns_t_minfo = 14, /* Mailbox information. */ rk_ns_t_mx = 15, /* Mail routing information. */ rk_ns_t_txt = 16, /* Text strings. */ rk_ns_t_rp = 17, /* Responsible person. */ rk_ns_t_afsdb = 18, /* AFS cell database. */ rk_ns_t_x25 = 19, /* X_25 calling address. */ rk_ns_t_isdn = 20, /* ISDN calling address. */ rk_ns_t_rt = 21, /* Router. */ rk_ns_t_nsap = 22, /* NSAP address. */ rk_ns_t_nsap_ptr = 23, /* Reverse NSAP lookup (deprecated). */ rk_ns_t_sig = 24, /* Security signature. */ rk_ns_t_key = 25, /* Security key. */ rk_ns_t_px = 26, /* X.400 mail mapping. */ rk_ns_t_gpos = 27, /* Geographical position (withdrawn). */ rk_ns_t_aaaa = 28, /* Ip6 Address. */ rk_ns_t_loc = 29, /* Location Information. */ rk_ns_t_nxt = 30, /* Next domain (security). */ rk_ns_t_eid = 31, /* Endpoint identifier. */ rk_ns_t_nimloc = 32, /* Nimrod Locator. */ rk_ns_t_srv = 33, /* Server Selection. */ rk_ns_t_atma = 34, /* ATM Address */ rk_ns_t_naptr = 35, /* Naming Authority PoinTeR */ rk_ns_t_kx = 36, /* Key Exchange */ rk_ns_t_cert = 37, /* Certification record */ rk_ns_t_a6 = 38, /* IPv6 address (deprecates AAAA) */ rk_ns_t_dname = 39, /* Non-terminal DNAME (for IPv6) */ rk_ns_t_sink = 40, /* Kitchen sink (experimentatl) */ rk_ns_t_opt = 41, /* EDNS0 option (meta-RR) */ rk_ns_t_apl = 42, /* Address prefix list (RFC 3123) */ rk_ns_t_ds = 43, /* Delegation Signer (RFC 3658) */ rk_ns_t_sshfp = 44, /* SSH fingerprint */ rk_ns_t_tkey = 249, /* Transaction key */ rk_ns_t_tsig = 250, /* Transaction signature. */ rk_ns_t_ixfr = 251, /* Incremental zone transfer. */ rk_ns_t_axfr = 252, /* Transfer zone of authority. */ rk_ns_t_mailb = 253, /* Transfer mailbox records. */ rk_ns_t_maila = 254, /* Transfer mail agent records. */ rk_ns_t_any = 255, /* Wildcard match. */ rk_ns_t_zxfr = 256, /* BIND-specific, nonstandard. */ rk_ns_t_max = 65536 }; #ifndef MAXDNAME #define MAXDNAME 1025 #endif #define mx_record rk_mx_record #define srv_record rk_srv_record #define key_record rk_key_record #define sig_record rk_sig_record #define cert_record rk_cert_record #define sshfp_record rk_sshfp_record struct rk_dns_query{ char *domain; unsigned type; unsigned class; }; struct rk_mx_record{ unsigned preference; char domain[1]; }; struct rk_srv_record{ unsigned priority; unsigned weight; unsigned port; char target[1]; }; struct rk_key_record { unsigned flags; unsigned protocol; unsigned algorithm; size_t key_len; u_char key_data[1]; }; struct rk_sig_record { unsigned type; unsigned algorithm; unsigned labels; unsigned orig_ttl; unsigned sig_expiration; unsigned sig_inception; unsigned key_tag; char *signer; size_t sig_len; char sig_data[1]; /* also includes signer */ }; struct rk_cert_record { unsigned type; unsigned tag; unsigned algorithm; size_t cert_len; u_char cert_data[1]; }; struct rk_sshfp_record { unsigned algorithm; unsigned type; size_t sshfp_len; u_char sshfp_data[1]; }; struct rk_ds_record { unsigned key_tag; unsigned algorithm; unsigned digest_type; size_t digest_len; u_char digest_data[1]; }; struct rk_resource_record{ char *domain; unsigned type; unsigned class; unsigned ttl; unsigned size; union { void *data; struct rk_mx_record *mx; struct rk_mx_record *afsdb; /* mx and afsdb are identical */ struct rk_srv_record *srv; struct in_addr *a; char *txt; struct rk_key_record *key; struct rk_cert_record *cert; struct rk_sig_record *sig; struct rk_sshfp_record *sshfp; struct rk_ds_record *ds; }u; struct rk_resource_record *next; }; #define rk_DNS_MAX_PACKET_SIZE 0xffff struct rk_dns_header { unsigned id; unsigned flags; #define rk_DNS_HEADER_RESPONSE_FLAG 1 #define rk_DNS_HEADER_AUTHORITIVE_ANSWER 2 #define rk_DNS_HEADER_TRUNCATED_MESSAGE 4 #define rk_DNS_HEADER_RECURSION_DESIRED 8 #define rk_DNS_HEADER_RECURSION_AVAILABLE 16 #define rk_DNS_HEADER_AUTHENTIC_DATA 32 #define rk_DNS_HEADER_CHECKING_DISABLED 64 unsigned opcode; unsigned response_code; unsigned qdcount; unsigned ancount; unsigned nscount; unsigned arcount; }; struct rk_dns_reply{ struct rk_dns_header h; struct rk_dns_query q; struct rk_resource_record *head; }; #ifdef __cplusplus extern "C" { #endif ROKEN_LIB_FUNCTION struct rk_dns_reply* ROKEN_LIB_CALL rk_dns_lookup(const char *, const char *); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL rk_dns_free_data(struct rk_dns_reply *); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL rk_dns_string_to_type(const char *name); ROKEN_LIB_FUNCTION const char * ROKEN_LIB_CALL rk_dns_type_to_string(int type); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL rk_dns_srv_order(struct rk_dns_reply*); #ifdef __cplusplus } #endif #endif /* __RESOLVE_H__ */ pykrb5-0.8.0/build_helpers/heimdal/include/rfc2459_asn1.h000066400000000000000000002303441505521762700230130ustar00rootroot00000000000000/* Generated from ./rfc2459.asn1 */ /* Do not edit */ #ifndef __rfc2459_asn1_h__ #define __rfc2459_asn1_h__ #include #include #ifndef __asn1_common_definitions__ #define __asn1_common_definitions__ #ifndef __HEIM_BASE_DATA__ #define __HEIM_BASE_DATA__ 1 struct heim_base_data { size_t length; void *data; }; typedef struct heim_base_data heim_octet_string; #endif typedef struct heim_integer { size_t length; void *data; int negative; } heim_integer; typedef char *heim_general_string; typedef char *heim_utf8_string; typedef struct heim_base_data heim_printable_string; typedef struct heim_base_data heim_ia5_string; typedef struct heim_bmp_string { size_t length; uint16_t *data; } heim_bmp_string; typedef struct heim_universal_string { size_t length; uint32_t *data; } heim_universal_string; typedef char *heim_visible_string; typedef struct heim_oid { size_t length; unsigned *components; } heim_oid; typedef struct heim_bit_string { size_t length; void *data; } heim_bit_string; typedef struct heim_base_data heim_any; typedef struct heim_base_data heim_any_set; #define ASN1_MALLOC_ENCODE(T, B, BL, S, L, R) \ do { \ (BL) = length_##T((S)); \ (B) = malloc((BL)); \ if((B) == NULL) { \ (R) = ENOMEM; \ } else { \ (R) = encode_##T(((unsigned char*)(B)) + (BL) - 1, (BL), \ (S), (L)); \ if((R) != 0) { \ free((B)); \ (B) = NULL; \ } \ } \ } while (0) #ifdef _WIN32 #ifndef ASN1_LIB #define ASN1EXP __declspec(dllimport) #else #define ASN1EXP #endif #define ASN1CALL __stdcall #else #define ASN1EXP #define ASN1CALL #endif struct units; #endif #include /* Version ::= INTEGER { rfc3280_version_1(0), rfc3280_version_2(1), rfc3280_version_3(2) } */ typedef enum Version { rfc3280_version_1 = 0, rfc3280_version_2 = 1, rfc3280_version_3 = 2 } Version; ASN1EXP int ASN1CALL decode_Version(const unsigned char *, size_t, Version *, size_t *); ASN1EXP int ASN1CALL encode_Version(unsigned char *, size_t, const Version *, size_t *); ASN1EXP size_t ASN1CALL length_Version(const Version *); ASN1EXP int ASN1CALL copy_Version (const Version *, Version *); ASN1EXP void ASN1CALL free_Version (Version *); /* OBJECT IDENTIFIER id-pkcs-1 ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs_1; #define ASN1_OID_ID_PKCS_1 (&asn1_oid_id_pkcs_1) /* OBJECT IDENTIFIER id-pkcs1-rsaEncryption ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) label-less(1) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs1_rsaEncryption; #define ASN1_OID_ID_PKCS1_RSAENCRYPTION (&asn1_oid_id_pkcs1_rsaEncryption) /* OBJECT IDENTIFIER id-pkcs1-md2WithRSAEncryption ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) label-less(1) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs1_md2WithRSAEncryption; #define ASN1_OID_ID_PKCS1_MD2WITHRSAENCRYPTION (&asn1_oid_id_pkcs1_md2WithRSAEncryption) /* OBJECT IDENTIFIER id-pkcs1-md5WithRSAEncryption ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) label-less(1) label-less(4) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs1_md5WithRSAEncryption; #define ASN1_OID_ID_PKCS1_MD5WITHRSAENCRYPTION (&asn1_oid_id_pkcs1_md5WithRSAEncryption) /* OBJECT IDENTIFIER id-pkcs1-sha1WithRSAEncryption ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) label-less(1) label-less(5) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs1_sha1WithRSAEncryption; #define ASN1_OID_ID_PKCS1_SHA1WITHRSAENCRYPTION (&asn1_oid_id_pkcs1_sha1WithRSAEncryption) /* OBJECT IDENTIFIER id-pkcs1-sha256WithRSAEncryption ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) label-less(1) label-less(11) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs1_sha256WithRSAEncryption; #define ASN1_OID_ID_PKCS1_SHA256WITHRSAENCRYPTION (&asn1_oid_id_pkcs1_sha256WithRSAEncryption) /* OBJECT IDENTIFIER id-pkcs1-sha384WithRSAEncryption ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) label-less(1) label-less(12) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs1_sha384WithRSAEncryption; #define ASN1_OID_ID_PKCS1_SHA384WITHRSAENCRYPTION (&asn1_oid_id_pkcs1_sha384WithRSAEncryption) /* OBJECT IDENTIFIER id-pkcs1-sha512WithRSAEncryption ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) label-less(1) label-less(13) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs1_sha512WithRSAEncryption; #define ASN1_OID_ID_PKCS1_SHA512WITHRSAENCRYPTION (&asn1_oid_id_pkcs1_sha512WithRSAEncryption) /* OBJECT IDENTIFIER id-heim-rsa-pkcs1-x509 ::= { label-less(1) label-less(2) label-less(752) label-less(43) label-less(16) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_heim_rsa_pkcs1_x509; #define ASN1_OID_ID_HEIM_RSA_PKCS1_X509 (&asn1_oid_id_heim_rsa_pkcs1_x509) /* OBJECT IDENTIFIER id-pkcs-2 ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs_2; #define ASN1_OID_ID_PKCS_2 (&asn1_oid_id_pkcs_2) /* OBJECT IDENTIFIER id-pkcs2-md2 ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) label-less(2) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs2_md2; #define ASN1_OID_ID_PKCS2_MD2 (&asn1_oid_id_pkcs2_md2) /* OBJECT IDENTIFIER id-pkcs2-md4 ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) label-less(2) label-less(4) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs2_md4; #define ASN1_OID_ID_PKCS2_MD4 (&asn1_oid_id_pkcs2_md4) /* OBJECT IDENTIFIER id-pkcs2-md5 ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) label-less(2) label-less(5) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs2_md5; #define ASN1_OID_ID_PKCS2_MD5 (&asn1_oid_id_pkcs2_md5) /* OBJECT IDENTIFIER id-rsa-digestAlgorithm ::= { iso(1) member-body(2) us(840) rsadsi(113549) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_rsa_digestAlgorithm; #define ASN1_OID_ID_RSA_DIGESTALGORITHM (&asn1_oid_id_rsa_digestAlgorithm) /* OBJECT IDENTIFIER id-rsa-digest-md2 ::= { iso(1) member-body(2) us(840) rsadsi(113549) label-less(2) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_rsa_digest_md2; #define ASN1_OID_ID_RSA_DIGEST_MD2 (&asn1_oid_id_rsa_digest_md2) /* OBJECT IDENTIFIER id-rsa-digest-md4 ::= { iso(1) member-body(2) us(840) rsadsi(113549) label-less(2) label-less(4) } */ extern ASN1EXP const heim_oid asn1_oid_id_rsa_digest_md4; #define ASN1_OID_ID_RSA_DIGEST_MD4 (&asn1_oid_id_rsa_digest_md4) /* OBJECT IDENTIFIER id-rsa-digest-md5 ::= { iso(1) member-body(2) us(840) rsadsi(113549) label-less(2) label-less(5) } */ extern ASN1EXP const heim_oid asn1_oid_id_rsa_digest_md5; #define ASN1_OID_ID_RSA_DIGEST_MD5 (&asn1_oid_id_rsa_digest_md5) /* OBJECT IDENTIFIER id-pkcs-3 ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) label-less(3) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs_3; #define ASN1_OID_ID_PKCS_3 (&asn1_oid_id_pkcs_3) /* OBJECT IDENTIFIER id-pkcs3-rc2-cbc ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) label-less(3) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs3_rc2_cbc; #define ASN1_OID_ID_PKCS3_RC2_CBC (&asn1_oid_id_pkcs3_rc2_cbc) /* OBJECT IDENTIFIER id-pkcs3-rc4 ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) label-less(3) label-less(4) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs3_rc4; #define ASN1_OID_ID_PKCS3_RC4 (&asn1_oid_id_pkcs3_rc4) /* OBJECT IDENTIFIER id-pkcs3-des-ede3-cbc ::= { iso(1) member-body(2) us(840) rsadsi(113549) pkcs(1) label-less(3) label-less(7) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkcs3_des_ede3_cbc; #define ASN1_OID_ID_PKCS3_DES_EDE3_CBC (&asn1_oid_id_pkcs3_des_ede3_cbc) /* OBJECT IDENTIFIER id-rsadsi-encalg ::= { iso(1) member-body(2) us(840) rsadsi(113549) label-less(3) } */ extern ASN1EXP const heim_oid asn1_oid_id_rsadsi_encalg; #define ASN1_OID_ID_RSADSI_ENCALG (&asn1_oid_id_rsadsi_encalg) /* OBJECT IDENTIFIER id-rsadsi-rc2-cbc ::= { iso(1) member-body(2) us(840) rsadsi(113549) label-less(3) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_rsadsi_rc2_cbc; #define ASN1_OID_ID_RSADSI_RC2_CBC (&asn1_oid_id_rsadsi_rc2_cbc) /* OBJECT IDENTIFIER id-rsadsi-des-ede3-cbc ::= { iso(1) member-body(2) us(840) rsadsi(113549) label-less(3) label-less(7) } */ extern ASN1EXP const heim_oid asn1_oid_id_rsadsi_des_ede3_cbc; #define ASN1_OID_ID_RSADSI_DES_EDE3_CBC (&asn1_oid_id_rsadsi_des_ede3_cbc) /* OBJECT IDENTIFIER id-secsig-sha-1 ::= { iso(1) identified-organization(3) oiw(14) secsig(3) algorithm(2) label-less(26) } */ extern ASN1EXP const heim_oid asn1_oid_id_secsig_sha_1; #define ASN1_OID_ID_SECSIG_SHA_1 (&asn1_oid_id_secsig_sha_1) /* OBJECT IDENTIFIER id-secsig-sha-1WithRSAEncryption ::= { iso(1) identified-organization(3) oiw(14) secsig(3) algorithm(2) label-less(29) } */ extern ASN1EXP const heim_oid asn1_oid_id_secsig_sha_1WithRSAEncryption; #define ASN1_OID_ID_SECSIG_SHA_1WITHRSAENCRYPTION (&asn1_oid_id_secsig_sha_1WithRSAEncryption) /* OBJECT IDENTIFIER id-nistAlgorithm ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) } */ extern ASN1EXP const heim_oid asn1_oid_id_nistAlgorithm; #define ASN1_OID_ID_NISTALGORITHM (&asn1_oid_id_nistAlgorithm) /* OBJECT IDENTIFIER id-nist-aes-algs ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_nist_aes_algs; #define ASN1_OID_ID_NIST_AES_ALGS (&asn1_oid_id_nist_aes_algs) /* OBJECT IDENTIFIER id-aes-128-cbc ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(1) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_aes_128_cbc; #define ASN1_OID_ID_AES_128_CBC (&asn1_oid_id_aes_128_cbc) /* OBJECT IDENTIFIER id-aes-192-cbc ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(1) label-less(22) } */ extern ASN1EXP const heim_oid asn1_oid_id_aes_192_cbc; #define ASN1_OID_ID_AES_192_CBC (&asn1_oid_id_aes_192_cbc) /* OBJECT IDENTIFIER id-aes-256-cbc ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(1) label-less(42) } */ extern ASN1EXP const heim_oid asn1_oid_id_aes_256_cbc; #define ASN1_OID_ID_AES_256_CBC (&asn1_oid_id_aes_256_cbc) /* OBJECT IDENTIFIER id-nist-sha-algs ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_nist_sha_algs; #define ASN1_OID_ID_NIST_SHA_ALGS (&asn1_oid_id_nist_sha_algs) /* OBJECT IDENTIFIER id-sha256 ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(2) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_sha256; #define ASN1_OID_ID_SHA256 (&asn1_oid_id_sha256) /* OBJECT IDENTIFIER id-sha224 ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(2) label-less(4) } */ extern ASN1EXP const heim_oid asn1_oid_id_sha224; #define ASN1_OID_ID_SHA224 (&asn1_oid_id_sha224) /* OBJECT IDENTIFIER id-sha384 ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(2) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_sha384; #define ASN1_OID_ID_SHA384 (&asn1_oid_id_sha384) /* OBJECT IDENTIFIER id-sha512 ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) gov(101) csor(3) label-less(4) label-less(2) label-less(3) } */ extern ASN1EXP const heim_oid asn1_oid_id_sha512; #define ASN1_OID_ID_SHA512 (&asn1_oid_id_sha512) /* OBJECT IDENTIFIER id-dhpublicnumber ::= { iso(1) member-body(2) us(840) ansi-x942(10046) number-type(2) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_dhpublicnumber; #define ASN1_OID_ID_DHPUBLICNUMBER (&asn1_oid_id_dhpublicnumber) /* OBJECT IDENTIFIER id-ecPublicKey ::= { iso(1) member-body(2) us(840) ansi-X9-62(10045) keyType(2) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_ecPublicKey; #define ASN1_OID_ID_ECPUBLICKEY (&asn1_oid_id_ecPublicKey) /* OBJECT IDENTIFIER id-ecDH ::= { iso(1) identified-organization(3) certicom(132) schemes(1) ecdh(12) } */ extern ASN1EXP const heim_oid asn1_oid_id_ecDH; #define ASN1_OID_ID_ECDH (&asn1_oid_id_ecDH) /* OBJECT IDENTIFIER id-ecMQV ::= { iso(1) identified-organization(3) certicom(132) schemes(1) ecmqv(13) } */ extern ASN1EXP const heim_oid asn1_oid_id_ecMQV; #define ASN1_OID_ID_ECMQV (&asn1_oid_id_ecMQV) /* OBJECT IDENTIFIER id-ecdsa-with-SHA512 ::= { iso(1) member-body(2) us(840) ansi-X9-62(10045) signatures(4) ecdsa-with-SHA2(3) label-less(4) } */ extern ASN1EXP const heim_oid asn1_oid_id_ecdsa_with_SHA512; #define ASN1_OID_ID_ECDSA_WITH_SHA512 (&asn1_oid_id_ecdsa_with_SHA512) /* OBJECT IDENTIFIER id-ecdsa-with-SHA384 ::= { iso(1) member-body(2) us(840) ansi-X9-62(10045) signatures(4) ecdsa-with-SHA2(3) label-less(3) } */ extern ASN1EXP const heim_oid asn1_oid_id_ecdsa_with_SHA384; #define ASN1_OID_ID_ECDSA_WITH_SHA384 (&asn1_oid_id_ecdsa_with_SHA384) /* OBJECT IDENTIFIER id-ecdsa-with-SHA256 ::= { iso(1) member-body(2) us(840) ansi-X9-62(10045) signatures(4) ecdsa-with-SHA2(3) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_ecdsa_with_SHA256; #define ASN1_OID_ID_ECDSA_WITH_SHA256 (&asn1_oid_id_ecdsa_with_SHA256) /* OBJECT IDENTIFIER id-ecdsa-with-SHA224 ::= { iso(1) member-body(2) us(840) ansi-X9-62(10045) signatures(4) ecdsa-with-SHA2(3) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_ecdsa_with_SHA224; #define ASN1_OID_ID_ECDSA_WITH_SHA224 (&asn1_oid_id_ecdsa_with_SHA224) /* OBJECT IDENTIFIER id-ecdsa-with-SHA1 ::= { iso(1) member-body(2) us(840) ansi-X9-62(10045) signatures(4) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_ecdsa_with_SHA1; #define ASN1_OID_ID_ECDSA_WITH_SHA1 (&asn1_oid_id_ecdsa_with_SHA1) /* OBJECT IDENTIFIER id-ec-group-secp256r1 ::= { iso(1) member-body(2) us(840) ansi-X9-62(10045) curves(3) prime(1) label-less(7) } */ extern ASN1EXP const heim_oid asn1_oid_id_ec_group_secp256r1; #define ASN1_OID_ID_EC_GROUP_SECP256R1 (&asn1_oid_id_ec_group_secp256r1) /* OBJECT IDENTIFIER id-ec-group-secp160r1 ::= { iso(1) identified-organization(3) certicom(132) label-less(0) label-less(8) } */ extern ASN1EXP const heim_oid asn1_oid_id_ec_group_secp160r1; #define ASN1_OID_ID_EC_GROUP_SECP160R1 (&asn1_oid_id_ec_group_secp160r1) /* OBJECT IDENTIFIER id-ec-group-secp160r2 ::= { iso(1) identified-organization(3) certicom(132) label-less(0) label-less(30) } */ extern ASN1EXP const heim_oid asn1_oid_id_ec_group_secp160r2; #define ASN1_OID_ID_EC_GROUP_SECP160R2 (&asn1_oid_id_ec_group_secp160r2) /* OBJECT IDENTIFIER id-ec-group-secp224r1 ::= { iso(1) identified-organization(3) certicom(132) label-less(0) label-less(33) } */ extern ASN1EXP const heim_oid asn1_oid_id_ec_group_secp224r1; #define ASN1_OID_ID_EC_GROUP_SECP224R1 (&asn1_oid_id_ec_group_secp224r1) /* OBJECT IDENTIFIER id-ec-group-secp384r1 ::= { iso(1) identified-organization(3) certicom(132) label-less(0) label-less(34) } */ extern ASN1EXP const heim_oid asn1_oid_id_ec_group_secp384r1; #define ASN1_OID_ID_EC_GROUP_SECP384R1 (&asn1_oid_id_ec_group_secp384r1) /* OBJECT IDENTIFIER id-ec-group-secp521r1 ::= { iso(1) identified-organization(3) certicom(132) label-less(0) label-less(35) } */ extern ASN1EXP const heim_oid asn1_oid_id_ec_group_secp521r1; #define ASN1_OID_ID_EC_GROUP_SECP521R1 (&asn1_oid_id_ec_group_secp521r1) /* OBJECT IDENTIFIER id-x9-57 ::= { iso(1) member-body(2) us(840) ansi-x942(10046) label-less(4) } */ extern ASN1EXP const heim_oid asn1_oid_id_x9_57; #define ASN1_OID_ID_X9_57 (&asn1_oid_id_x9_57) /* OBJECT IDENTIFIER id-dsa ::= { iso(1) member-body(2) us(840) ansi-x942(10046) label-less(4) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_dsa; #define ASN1_OID_ID_DSA (&asn1_oid_id_dsa) /* OBJECT IDENTIFIER id-dsa-with-sha1 ::= { iso(1) member-body(2) us(840) ansi-x942(10046) label-less(4) label-less(3) } */ extern ASN1EXP const heim_oid asn1_oid_id_dsa_with_sha1; #define ASN1_OID_ID_DSA_WITH_SHA1 (&asn1_oid_id_dsa_with_sha1) /* OBJECT IDENTIFIER id-x520-at ::= { joint-iso-ccitt(2) ds(5) label-less(4) } */ extern ASN1EXP const heim_oid asn1_oid_id_x520_at; #define ASN1_OID_ID_X520_AT (&asn1_oid_id_x520_at) /* OBJECT IDENTIFIER id-at-commonName ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(3) } */ extern ASN1EXP const heim_oid asn1_oid_id_at_commonName; #define ASN1_OID_ID_AT_COMMONNAME (&asn1_oid_id_at_commonName) /* OBJECT IDENTIFIER id-at-surname ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(4) } */ extern ASN1EXP const heim_oid asn1_oid_id_at_surname; #define ASN1_OID_ID_AT_SURNAME (&asn1_oid_id_at_surname) /* OBJECT IDENTIFIER id-at-serialNumber ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(5) } */ extern ASN1EXP const heim_oid asn1_oid_id_at_serialNumber; #define ASN1_OID_ID_AT_SERIALNUMBER (&asn1_oid_id_at_serialNumber) /* OBJECT IDENTIFIER id-at-countryName ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(6) } */ extern ASN1EXP const heim_oid asn1_oid_id_at_countryName; #define ASN1_OID_ID_AT_COUNTRYNAME (&asn1_oid_id_at_countryName) /* OBJECT IDENTIFIER id-at-localityName ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(7) } */ extern ASN1EXP const heim_oid asn1_oid_id_at_localityName; #define ASN1_OID_ID_AT_LOCALITYNAME (&asn1_oid_id_at_localityName) /* OBJECT IDENTIFIER id-at-stateOrProvinceName ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(8) } */ extern ASN1EXP const heim_oid asn1_oid_id_at_stateOrProvinceName; #define ASN1_OID_ID_AT_STATEORPROVINCENAME (&asn1_oid_id_at_stateOrProvinceName) /* OBJECT IDENTIFIER id-at-streetAddress ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(9) } */ extern ASN1EXP const heim_oid asn1_oid_id_at_streetAddress; #define ASN1_OID_ID_AT_STREETADDRESS (&asn1_oid_id_at_streetAddress) /* OBJECT IDENTIFIER id-at-organizationName ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(10) } */ extern ASN1EXP const heim_oid asn1_oid_id_at_organizationName; #define ASN1_OID_ID_AT_ORGANIZATIONNAME (&asn1_oid_id_at_organizationName) /* OBJECT IDENTIFIER id-at-organizationalUnitName ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(11) } */ extern ASN1EXP const heim_oid asn1_oid_id_at_organizationalUnitName; #define ASN1_OID_ID_AT_ORGANIZATIONALUNITNAME (&asn1_oid_id_at_organizationalUnitName) /* OBJECT IDENTIFIER id-at-title ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(12) } */ extern ASN1EXP const heim_oid asn1_oid_id_at_title; #define ASN1_OID_ID_AT_TITLE (&asn1_oid_id_at_title) /* OBJECT IDENTIFIER id-at-description ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(13) } */ extern ASN1EXP const heim_oid asn1_oid_id_at_description; #define ASN1_OID_ID_AT_DESCRIPTION (&asn1_oid_id_at_description) /* OBJECT IDENTIFIER id-at-name ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(41) } */ extern ASN1EXP const heim_oid asn1_oid_id_at_name; #define ASN1_OID_ID_AT_NAME (&asn1_oid_id_at_name) /* OBJECT IDENTIFIER id-at-givenName ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(42) } */ extern ASN1EXP const heim_oid asn1_oid_id_at_givenName; #define ASN1_OID_ID_AT_GIVENNAME (&asn1_oid_id_at_givenName) /* OBJECT IDENTIFIER id-at-initials ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(43) } */ extern ASN1EXP const heim_oid asn1_oid_id_at_initials; #define ASN1_OID_ID_AT_INITIALS (&asn1_oid_id_at_initials) /* OBJECT IDENTIFIER id-at-generationQualifier ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(44) } */ extern ASN1EXP const heim_oid asn1_oid_id_at_generationQualifier; #define ASN1_OID_ID_AT_GENERATIONQUALIFIER (&asn1_oid_id_at_generationQualifier) /* OBJECT IDENTIFIER id-at-pseudonym ::= { joint-iso-ccitt(2) ds(5) label-less(4) label-less(65) } */ extern ASN1EXP const heim_oid asn1_oid_id_at_pseudonym; #define ASN1_OID_ID_AT_PSEUDONYM (&asn1_oid_id_at_pseudonym) /* OBJECT IDENTIFIER id-Userid ::= { label-less(0) label-less(9) label-less(2342) label-less(19200300) label-less(100) label-less(1) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_Userid; #define ASN1_OID_ID_USERID (&asn1_oid_id_Userid) /* OBJECT IDENTIFIER id-domainComponent ::= { label-less(0) label-less(9) label-less(2342) label-less(19200300) label-less(100) label-less(1) label-less(25) } */ extern ASN1EXP const heim_oid asn1_oid_id_domainComponent; #define ASN1_OID_ID_DOMAINCOMPONENT (&asn1_oid_id_domainComponent) /* OBJECT IDENTIFIER id-x509-ce ::= { joint-iso-ccitt(2) ds(5) label-less(29) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce; #define ASN1_OID_ID_X509_CE (&asn1_oid_id_x509_ce) /* AlgorithmIdentifier ::= SEQUENCE { algorithm OBJECT IDENTIFIER, parameters heim_any OPTIONAL, } */ typedef struct AlgorithmIdentifier { heim_oid algorithm; heim_any *parameters; } AlgorithmIdentifier; ASN1EXP int ASN1CALL decode_AlgorithmIdentifier(const unsigned char *, size_t, AlgorithmIdentifier *, size_t *); ASN1EXP int ASN1CALL encode_AlgorithmIdentifier(unsigned char *, size_t, const AlgorithmIdentifier *, size_t *); ASN1EXP size_t ASN1CALL length_AlgorithmIdentifier(const AlgorithmIdentifier *); ASN1EXP int ASN1CALL copy_AlgorithmIdentifier (const AlgorithmIdentifier *, AlgorithmIdentifier *); ASN1EXP void ASN1CALL free_AlgorithmIdentifier (AlgorithmIdentifier *); /* AttributeType ::= OBJECT IDENTIFIER */ typedef heim_oid AttributeType; ASN1EXP int ASN1CALL decode_AttributeType(const unsigned char *, size_t, AttributeType *, size_t *); ASN1EXP int ASN1CALL encode_AttributeType(unsigned char *, size_t, const AttributeType *, size_t *); ASN1EXP size_t ASN1CALL length_AttributeType(const AttributeType *); ASN1EXP int ASN1CALL copy_AttributeType (const AttributeType *, AttributeType *); ASN1EXP void ASN1CALL free_AttributeType (AttributeType *); /* AttributeValue ::= heim_any */ typedef heim_any AttributeValue; ASN1EXP int ASN1CALL decode_AttributeValue(const unsigned char *, size_t, AttributeValue *, size_t *); ASN1EXP int ASN1CALL encode_AttributeValue(unsigned char *, size_t, const AttributeValue *, size_t *); ASN1EXP size_t ASN1CALL length_AttributeValue(const AttributeValue *); ASN1EXP int ASN1CALL copy_AttributeValue (const AttributeValue *, AttributeValue *); ASN1EXP void ASN1CALL free_AttributeValue (AttributeValue *); /* DirectoryString ::= CHOICE { ia5String IA5String, teletexString TeletexString, printableString PrintableString, universalString UniversalString, utf8String UTF8String, bmpString BMPString, } */ typedef struct DirectoryString { enum DirectoryString_enum { choice_DirectoryString_ia5String = 1, choice_DirectoryString_teletexString, choice_DirectoryString_printableString, choice_DirectoryString_universalString, choice_DirectoryString_utf8String, choice_DirectoryString_bmpString } element; union { heim_ia5_string ia5String; heim_general_string teletexString; heim_printable_string printableString; heim_universal_string universalString; heim_utf8_string utf8String; heim_bmp_string bmpString; } u; } DirectoryString; ASN1EXP int ASN1CALL decode_DirectoryString(const unsigned char *, size_t, DirectoryString *, size_t *); ASN1EXP int ASN1CALL encode_DirectoryString(unsigned char *, size_t, const DirectoryString *, size_t *); ASN1EXP size_t ASN1CALL length_DirectoryString(const DirectoryString *); ASN1EXP int ASN1CALL copy_DirectoryString (const DirectoryString *, DirectoryString *); ASN1EXP void ASN1CALL free_DirectoryString (DirectoryString *); /* Attribute ::= SEQUENCE { type AttributeType, value SET OF heim_any, } */ typedef struct Attribute { AttributeType type; struct Attribute_value { unsigned int len; heim_any *val; } value; } Attribute; ASN1EXP int ASN1CALL decode_Attribute(const unsigned char *, size_t, Attribute *, size_t *); ASN1EXP int ASN1CALL encode_Attribute(unsigned char *, size_t, const Attribute *, size_t *); ASN1EXP size_t ASN1CALL length_Attribute(const Attribute *); ASN1EXP int ASN1CALL copy_Attribute (const Attribute *, Attribute *); ASN1EXP void ASN1CALL free_Attribute (Attribute *); /* AttributeTypeAndValue ::= SEQUENCE { type AttributeType, value DirectoryString, } */ typedef struct AttributeTypeAndValue { AttributeType type; DirectoryString value; } AttributeTypeAndValue; ASN1EXP int ASN1CALL decode_AttributeTypeAndValue(const unsigned char *, size_t, AttributeTypeAndValue *, size_t *); ASN1EXP int ASN1CALL encode_AttributeTypeAndValue(unsigned char *, size_t, const AttributeTypeAndValue *, size_t *); ASN1EXP size_t ASN1CALL length_AttributeTypeAndValue(const AttributeTypeAndValue *); ASN1EXP int ASN1CALL copy_AttributeTypeAndValue (const AttributeTypeAndValue *, AttributeTypeAndValue *); ASN1EXP void ASN1CALL free_AttributeTypeAndValue (AttributeTypeAndValue *); /* RelativeDistinguishedName ::= SET OF AttributeTypeAndValue */ typedef struct RelativeDistinguishedName { unsigned int len; AttributeTypeAndValue *val; } RelativeDistinguishedName; ASN1EXP int ASN1CALL decode_RelativeDistinguishedName(const unsigned char *, size_t, RelativeDistinguishedName *, size_t *); ASN1EXP int ASN1CALL encode_RelativeDistinguishedName(unsigned char *, size_t, const RelativeDistinguishedName *, size_t *); ASN1EXP size_t ASN1CALL length_RelativeDistinguishedName(const RelativeDistinguishedName *); ASN1EXP int ASN1CALL copy_RelativeDistinguishedName (const RelativeDistinguishedName *, RelativeDistinguishedName *); ASN1EXP void ASN1CALL free_RelativeDistinguishedName (RelativeDistinguishedName *); /* RDNSequence ::= SEQUENCE OF RelativeDistinguishedName */ typedef struct RDNSequence { unsigned int len; RelativeDistinguishedName *val; } RDNSequence; ASN1EXP int ASN1CALL decode_RDNSequence(const unsigned char *, size_t, RDNSequence *, size_t *); ASN1EXP int ASN1CALL encode_RDNSequence(unsigned char *, size_t, const RDNSequence *, size_t *); ASN1EXP size_t ASN1CALL length_RDNSequence(const RDNSequence *); ASN1EXP int ASN1CALL copy_RDNSequence (const RDNSequence *, RDNSequence *); ASN1EXP void ASN1CALL free_RDNSequence (RDNSequence *); /* Name ::= CHOICE { rdnSequence RDNSequence, } */ typedef struct Name { heim_octet_string _save; enum Name_enum { choice_Name_rdnSequence = 1 } element; union { RDNSequence rdnSequence; } u; } Name; ASN1EXP int ASN1CALL decode_Name(const unsigned char *, size_t, Name *, size_t *); ASN1EXP int ASN1CALL encode_Name(unsigned char *, size_t, const Name *, size_t *); ASN1EXP size_t ASN1CALL length_Name(const Name *); ASN1EXP int ASN1CALL copy_Name (const Name *, Name *); ASN1EXP void ASN1CALL free_Name (Name *); /* CertificateSerialNumber ::= INTEGER */ typedef heim_integer CertificateSerialNumber; ASN1EXP int ASN1CALL decode_CertificateSerialNumber(const unsigned char *, size_t, CertificateSerialNumber *, size_t *); ASN1EXP int ASN1CALL encode_CertificateSerialNumber(unsigned char *, size_t, const CertificateSerialNumber *, size_t *); ASN1EXP size_t ASN1CALL length_CertificateSerialNumber(const CertificateSerialNumber *); ASN1EXP int ASN1CALL copy_CertificateSerialNumber (const CertificateSerialNumber *, CertificateSerialNumber *); ASN1EXP void ASN1CALL free_CertificateSerialNumber (CertificateSerialNumber *); /* Time ::= CHOICE { utcTime UTCTime, generalTime GeneralizedTime, } */ typedef struct Time { enum Time_enum { choice_Time_utcTime = 1, choice_Time_generalTime } element; union { time_t utcTime; time_t generalTime; } u; } Time; ASN1EXP int ASN1CALL decode_Time(const unsigned char *, size_t, Time *, size_t *); ASN1EXP int ASN1CALL encode_Time(unsigned char *, size_t, const Time *, size_t *); ASN1EXP size_t ASN1CALL length_Time(const Time *); ASN1EXP int ASN1CALL copy_Time (const Time *, Time *); ASN1EXP void ASN1CALL free_Time (Time *); /* Validity ::= SEQUENCE { notBefore Time, notAfter Time, } */ typedef struct Validity { Time notBefore; Time notAfter; } Validity; ASN1EXP int ASN1CALL decode_Validity(const unsigned char *, size_t, Validity *, size_t *); ASN1EXP int ASN1CALL encode_Validity(unsigned char *, size_t, const Validity *, size_t *); ASN1EXP size_t ASN1CALL length_Validity(const Validity *); ASN1EXP int ASN1CALL copy_Validity (const Validity *, Validity *); ASN1EXP void ASN1CALL free_Validity (Validity *); /* UniqueIdentifier ::= BIT STRING { } */ typedef heim_bit_string UniqueIdentifier; ASN1EXP int ASN1CALL decode_UniqueIdentifier(const unsigned char *, size_t, UniqueIdentifier *, size_t *); ASN1EXP int ASN1CALL encode_UniqueIdentifier(unsigned char *, size_t, const UniqueIdentifier *, size_t *); ASN1EXP size_t ASN1CALL length_UniqueIdentifier(const UniqueIdentifier *); ASN1EXP int ASN1CALL copy_UniqueIdentifier (const UniqueIdentifier *, UniqueIdentifier *); ASN1EXP void ASN1CALL free_UniqueIdentifier (UniqueIdentifier *); /* SubjectPublicKeyInfo ::= SEQUENCE { algorithm AlgorithmIdentifier, subjectPublicKey BIT STRING { }, } */ typedef struct SubjectPublicKeyInfo { AlgorithmIdentifier algorithm; heim_bit_string subjectPublicKey; } SubjectPublicKeyInfo; ASN1EXP int ASN1CALL decode_SubjectPublicKeyInfo(const unsigned char *, size_t, SubjectPublicKeyInfo *, size_t *); ASN1EXP int ASN1CALL encode_SubjectPublicKeyInfo(unsigned char *, size_t, const SubjectPublicKeyInfo *, size_t *); ASN1EXP size_t ASN1CALL length_SubjectPublicKeyInfo(const SubjectPublicKeyInfo *); ASN1EXP int ASN1CALL copy_SubjectPublicKeyInfo (const SubjectPublicKeyInfo *, SubjectPublicKeyInfo *); ASN1EXP void ASN1CALL free_SubjectPublicKeyInfo (SubjectPublicKeyInfo *); /* Extension ::= SEQUENCE { extnID OBJECT IDENTIFIER, critical BOOLEAN OPTIONAL, extnValue OCTET STRING, } */ typedef struct Extension { heim_oid extnID; int *critical; heim_octet_string extnValue; } Extension; ASN1EXP int ASN1CALL decode_Extension(const unsigned char *, size_t, Extension *, size_t *); ASN1EXP int ASN1CALL encode_Extension(unsigned char *, size_t, const Extension *, size_t *); ASN1EXP size_t ASN1CALL length_Extension(const Extension *); ASN1EXP int ASN1CALL copy_Extension (const Extension *, Extension *); ASN1EXP void ASN1CALL free_Extension (Extension *); /* Extensions ::= SEQUENCE OF Extension */ typedef struct Extensions { unsigned int len; Extension *val; } Extensions; ASN1EXP int ASN1CALL add_Extensions (Extensions *, const Extension *); ASN1EXP int ASN1CALL remove_Extensions (Extensions *, unsigned int); ASN1EXP int ASN1CALL decode_Extensions(const unsigned char *, size_t, Extensions *, size_t *); ASN1EXP int ASN1CALL encode_Extensions(unsigned char *, size_t, const Extensions *, size_t *); ASN1EXP size_t ASN1CALL length_Extensions(const Extensions *); ASN1EXP int ASN1CALL copy_Extensions (const Extensions *, Extensions *); ASN1EXP void ASN1CALL free_Extensions (Extensions *); /* TBSCertificate ::= SEQUENCE { version [0] Version OPTIONAL, serialNumber CertificateSerialNumber, signature AlgorithmIdentifier, issuer Name, validity Validity, subject Name, subjectPublicKeyInfo SubjectPublicKeyInfo, issuerUniqueID [1] IMPLICIT BIT STRING { } OPTIONAL, subjectUniqueID [2] IMPLICIT BIT STRING { } OPTIONAL, extensions [3] Extensions OPTIONAL, } */ typedef struct TBSCertificate { heim_octet_string _save; Version *version; CertificateSerialNumber serialNumber; AlgorithmIdentifier signature; Name issuer; Validity validity; Name subject; SubjectPublicKeyInfo subjectPublicKeyInfo; heim_bit_string *issuerUniqueID; heim_bit_string *subjectUniqueID; Extensions *extensions; } TBSCertificate; ASN1EXP int ASN1CALL decode_TBSCertificate(const unsigned char *, size_t, TBSCertificate *, size_t *); ASN1EXP int ASN1CALL encode_TBSCertificate(unsigned char *, size_t, const TBSCertificate *, size_t *); ASN1EXP size_t ASN1CALL length_TBSCertificate(const TBSCertificate *); ASN1EXP int ASN1CALL copy_TBSCertificate (const TBSCertificate *, TBSCertificate *); ASN1EXP void ASN1CALL free_TBSCertificate (TBSCertificate *); /* Certificate ::= SEQUENCE { tbsCertificate TBSCertificate, signatureAlgorithm AlgorithmIdentifier, signatureValue BIT STRING { }, } */ typedef struct Certificate { TBSCertificate tbsCertificate; AlgorithmIdentifier signatureAlgorithm; heim_bit_string signatureValue; } Certificate; ASN1EXP int ASN1CALL decode_Certificate(const unsigned char *, size_t, Certificate *, size_t *); ASN1EXP int ASN1CALL encode_Certificate(unsigned char *, size_t, const Certificate *, size_t *); ASN1EXP size_t ASN1CALL length_Certificate(const Certificate *); ASN1EXP int ASN1CALL copy_Certificate (const Certificate *, Certificate *); ASN1EXP void ASN1CALL free_Certificate (Certificate *); /* Certificates ::= SEQUENCE OF Certificate */ typedef struct Certificates { unsigned int len; Certificate *val; } Certificates; ASN1EXP int ASN1CALL decode_Certificates(const unsigned char *, size_t, Certificates *, size_t *); ASN1EXP int ASN1CALL encode_Certificates(unsigned char *, size_t, const Certificates *, size_t *); ASN1EXP size_t ASN1CALL length_Certificates(const Certificates *); ASN1EXP int ASN1CALL copy_Certificates (const Certificates *, Certificates *); ASN1EXP void ASN1CALL free_Certificates (Certificates *); /* ValidationParms ::= SEQUENCE { seed BIT STRING { }, pgenCounter INTEGER, } */ typedef struct ValidationParms { heim_bit_string seed; heim_integer pgenCounter; } ValidationParms; ASN1EXP int ASN1CALL decode_ValidationParms(const unsigned char *, size_t, ValidationParms *, size_t *); ASN1EXP int ASN1CALL encode_ValidationParms(unsigned char *, size_t, const ValidationParms *, size_t *); ASN1EXP size_t ASN1CALL length_ValidationParms(const ValidationParms *); ASN1EXP int ASN1CALL copy_ValidationParms (const ValidationParms *, ValidationParms *); ASN1EXP void ASN1CALL free_ValidationParms (ValidationParms *); /* DomainParameters ::= SEQUENCE { p INTEGER, g INTEGER, q INTEGER OPTIONAL, j INTEGER OPTIONAL, validationParms ValidationParms OPTIONAL, } */ typedef struct DomainParameters { heim_integer p; heim_integer g; heim_integer *q; heim_integer *j; ValidationParms *validationParms; } DomainParameters; ASN1EXP int ASN1CALL decode_DomainParameters(const unsigned char *, size_t, DomainParameters *, size_t *); ASN1EXP int ASN1CALL encode_DomainParameters(unsigned char *, size_t, const DomainParameters *, size_t *); ASN1EXP size_t ASN1CALL length_DomainParameters(const DomainParameters *); ASN1EXP int ASN1CALL copy_DomainParameters (const DomainParameters *, DomainParameters *); ASN1EXP void ASN1CALL free_DomainParameters (DomainParameters *); /* DHParameter ::= SEQUENCE { prime INTEGER, base INTEGER, privateValueLength INTEGER OPTIONAL, } */ typedef struct DHParameter { heim_integer prime; heim_integer base; heim_integer *privateValueLength; } DHParameter; ASN1EXP int ASN1CALL decode_DHParameter(const unsigned char *, size_t, DHParameter *, size_t *); ASN1EXP int ASN1CALL encode_DHParameter(unsigned char *, size_t, const DHParameter *, size_t *); ASN1EXP size_t ASN1CALL length_DHParameter(const DHParameter *); ASN1EXP int ASN1CALL copy_DHParameter (const DHParameter *, DHParameter *); ASN1EXP void ASN1CALL free_DHParameter (DHParameter *); /* DHPublicKey ::= INTEGER */ typedef heim_integer DHPublicKey; ASN1EXP int ASN1CALL decode_DHPublicKey(const unsigned char *, size_t, DHPublicKey *, size_t *); ASN1EXP int ASN1CALL encode_DHPublicKey(unsigned char *, size_t, const DHPublicKey *, size_t *); ASN1EXP size_t ASN1CALL length_DHPublicKey(const DHPublicKey *); ASN1EXP int ASN1CALL copy_DHPublicKey (const DHPublicKey *, DHPublicKey *); ASN1EXP void ASN1CALL free_DHPublicKey (DHPublicKey *); /* OtherName ::= SEQUENCE { type-id OBJECT IDENTIFIER, value [0] heim_any, } */ typedef struct OtherName { heim_oid type_id; heim_any value; } OtherName; ASN1EXP int ASN1CALL decode_OtherName(const unsigned char *, size_t, OtherName *, size_t *); ASN1EXP int ASN1CALL encode_OtherName(unsigned char *, size_t, const OtherName *, size_t *); ASN1EXP size_t ASN1CALL length_OtherName(const OtherName *); ASN1EXP int ASN1CALL copy_OtherName (const OtherName *, OtherName *); ASN1EXP void ASN1CALL free_OtherName (OtherName *); /* GeneralName ::= CHOICE { otherName [0] IMPLICIT SEQUENCE { type-id OBJECT IDENTIFIER, value [0] heim_any, }, rfc822Name [1] IMPLICIT IA5String, dNSName [2] IMPLICIT IA5String, directoryName [4] IMPLICIT CHOICE { rdnSequence RDNSequence, }, uniformResourceIdentifier [6] IMPLICIT IA5String, iPAddress [7] IMPLICIT OCTET STRING, registeredID [8] IMPLICIT OBJECT IDENTIFIER, } */ typedef struct GeneralName { enum GeneralName_enum { choice_GeneralName_otherName = 1, choice_GeneralName_rfc822Name, choice_GeneralName_dNSName, choice_GeneralName_directoryName, choice_GeneralName_uniformResourceIdentifier, choice_GeneralName_iPAddress, choice_GeneralName_registeredID } element; union { struct GeneralName_otherName { heim_oid type_id; heim_any value; } otherName; heim_ia5_string rfc822Name; heim_ia5_string dNSName; struct GeneralName_directoryName { enum GeneralName_directoryName_enum { choice_GeneralName_directoryName_rdnSequence = 1 } element; union { RDNSequence rdnSequence; } u; } directoryName; heim_ia5_string uniformResourceIdentifier; heim_octet_string iPAddress; heim_oid registeredID; } u; } GeneralName; ASN1EXP int ASN1CALL decode_GeneralName(const unsigned char *, size_t, GeneralName *, size_t *); ASN1EXP int ASN1CALL encode_GeneralName(unsigned char *, size_t, const GeneralName *, size_t *); ASN1EXP size_t ASN1CALL length_GeneralName(const GeneralName *); ASN1EXP int ASN1CALL copy_GeneralName (const GeneralName *, GeneralName *); ASN1EXP void ASN1CALL free_GeneralName (GeneralName *); /* GeneralNames ::= SEQUENCE OF GeneralName */ typedef struct GeneralNames { unsigned int len; GeneralName *val; } GeneralNames; ASN1EXP int ASN1CALL add_GeneralNames (GeneralNames *, const GeneralName *); ASN1EXP int ASN1CALL remove_GeneralNames (GeneralNames *, unsigned int); ASN1EXP int ASN1CALL decode_GeneralNames(const unsigned char *, size_t, GeneralNames *, size_t *); ASN1EXP int ASN1CALL encode_GeneralNames(unsigned char *, size_t, const GeneralNames *, size_t *); ASN1EXP size_t ASN1CALL length_GeneralNames(const GeneralNames *); ASN1EXP int ASN1CALL copy_GeneralNames (const GeneralNames *, GeneralNames *); ASN1EXP void ASN1CALL free_GeneralNames (GeneralNames *); /* OBJECT IDENTIFIER id-x509-ce-keyUsage ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(15) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_keyUsage; #define ASN1_OID_ID_X509_CE_KEYUSAGE (&asn1_oid_id_x509_ce_keyUsage) /* KeyUsage ::= BIT STRING { digitalSignature(0), nonRepudiation(1), keyEncipherment(2), dataEncipherment(3), keyAgreement(4), keyCertSign(5), cRLSign(6), encipherOnly(7), decipherOnly(8) } */ typedef struct KeyUsage { unsigned int digitalSignature:1; unsigned int nonRepudiation:1; unsigned int keyEncipherment:1; unsigned int dataEncipherment:1; unsigned int keyAgreement:1; unsigned int keyCertSign:1; unsigned int cRLSign:1; unsigned int encipherOnly:1; unsigned int decipherOnly:1; unsigned int _unused9:1; unsigned int _unused10:1; unsigned int _unused11:1; unsigned int _unused12:1; unsigned int _unused13:1; unsigned int _unused14:1; unsigned int _unused15:1; unsigned int _unused16:1; unsigned int _unused17:1; unsigned int _unused18:1; unsigned int _unused19:1; unsigned int _unused20:1; unsigned int _unused21:1; unsigned int _unused22:1; unsigned int _unused23:1; unsigned int _unused24:1; unsigned int _unused25:1; unsigned int _unused26:1; unsigned int _unused27:1; unsigned int _unused28:1; unsigned int _unused29:1; unsigned int _unused30:1; unsigned int _unused31:1; } KeyUsage; unsigned KeyUsage2int(KeyUsage); KeyUsage int2KeyUsage(unsigned); const struct units * asn1_KeyUsage_units(void); ASN1EXP int ASN1CALL decode_KeyUsage(const unsigned char *, size_t, KeyUsage *, size_t *); ASN1EXP int ASN1CALL encode_KeyUsage(unsigned char *, size_t, const KeyUsage *, size_t *); ASN1EXP size_t ASN1CALL length_KeyUsage(const KeyUsage *); ASN1EXP int ASN1CALL copy_KeyUsage (const KeyUsage *, KeyUsage *); ASN1EXP void ASN1CALL free_KeyUsage (KeyUsage *); /* OBJECT IDENTIFIER id-x509-ce-authorityKeyIdentifier ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(35) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_authorityKeyIdentifier; #define ASN1_OID_ID_X509_CE_AUTHORITYKEYIDENTIFIER (&asn1_oid_id_x509_ce_authorityKeyIdentifier) /* KeyIdentifier ::= OCTET STRING */ typedef heim_octet_string KeyIdentifier; ASN1EXP int ASN1CALL decode_KeyIdentifier(const unsigned char *, size_t, KeyIdentifier *, size_t *); ASN1EXP int ASN1CALL encode_KeyIdentifier(unsigned char *, size_t, const KeyIdentifier *, size_t *); ASN1EXP size_t ASN1CALL length_KeyIdentifier(const KeyIdentifier *); ASN1EXP int ASN1CALL copy_KeyIdentifier (const KeyIdentifier *, KeyIdentifier *); ASN1EXP void ASN1CALL free_KeyIdentifier (KeyIdentifier *); /* AuthorityKeyIdentifier ::= SEQUENCE { keyIdentifier [0] IMPLICIT OCTET STRING OPTIONAL, authorityCertIssuer [1] IMPLICIT SEQUENCE OF GeneralName OPTIONAL, authorityCertSerialNumber [2] IMPLICIT INTEGER OPTIONAL, } */ typedef struct AuthorityKeyIdentifier { heim_octet_string *keyIdentifier; struct AuthorityKeyIdentifier_authorityCertIssuer { unsigned int len; GeneralName *val; } *authorityCertIssuer; heim_integer *authorityCertSerialNumber; } AuthorityKeyIdentifier; ASN1EXP int ASN1CALL decode_AuthorityKeyIdentifier(const unsigned char *, size_t, AuthorityKeyIdentifier *, size_t *); ASN1EXP int ASN1CALL encode_AuthorityKeyIdentifier(unsigned char *, size_t, const AuthorityKeyIdentifier *, size_t *); ASN1EXP size_t ASN1CALL length_AuthorityKeyIdentifier(const AuthorityKeyIdentifier *); ASN1EXP int ASN1CALL copy_AuthorityKeyIdentifier (const AuthorityKeyIdentifier *, AuthorityKeyIdentifier *); ASN1EXP void ASN1CALL free_AuthorityKeyIdentifier (AuthorityKeyIdentifier *); /* OBJECT IDENTIFIER id-x509-ce-subjectKeyIdentifier ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(14) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_subjectKeyIdentifier; #define ASN1_OID_ID_X509_CE_SUBJECTKEYIDENTIFIER (&asn1_oid_id_x509_ce_subjectKeyIdentifier) /* SubjectKeyIdentifier ::= KeyIdentifier */ typedef KeyIdentifier SubjectKeyIdentifier; ASN1EXP int ASN1CALL decode_SubjectKeyIdentifier(const unsigned char *, size_t, SubjectKeyIdentifier *, size_t *); ASN1EXP int ASN1CALL encode_SubjectKeyIdentifier(unsigned char *, size_t, const SubjectKeyIdentifier *, size_t *); ASN1EXP size_t ASN1CALL length_SubjectKeyIdentifier(const SubjectKeyIdentifier *); ASN1EXP int ASN1CALL copy_SubjectKeyIdentifier (const SubjectKeyIdentifier *, SubjectKeyIdentifier *); ASN1EXP void ASN1CALL free_SubjectKeyIdentifier (SubjectKeyIdentifier *); /* OBJECT IDENTIFIER id-x509-ce-basicConstraints ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(19) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_basicConstraints; #define ASN1_OID_ID_X509_CE_BASICCONSTRAINTS (&asn1_oid_id_x509_ce_basicConstraints) /* BasicConstraints ::= SEQUENCE { cA BOOLEAN OPTIONAL, pathLenConstraint INTEGER (0..4294967295) OPTIONAL, } */ typedef struct BasicConstraints { int *cA; unsigned int *pathLenConstraint; } BasicConstraints; ASN1EXP int ASN1CALL decode_BasicConstraints(const unsigned char *, size_t, BasicConstraints *, size_t *); ASN1EXP int ASN1CALL encode_BasicConstraints(unsigned char *, size_t, const BasicConstraints *, size_t *); ASN1EXP size_t ASN1CALL length_BasicConstraints(const BasicConstraints *); ASN1EXP int ASN1CALL copy_BasicConstraints (const BasicConstraints *, BasicConstraints *); ASN1EXP void ASN1CALL free_BasicConstraints (BasicConstraints *); /* OBJECT IDENTIFIER id-x509-ce-nameConstraints ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(30) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_nameConstraints; #define ASN1_OID_ID_X509_CE_NAMECONSTRAINTS (&asn1_oid_id_x509_ce_nameConstraints) /* BaseDistance ::= INTEGER */ typedef heim_integer BaseDistance; ASN1EXP int ASN1CALL decode_BaseDistance(const unsigned char *, size_t, BaseDistance *, size_t *); ASN1EXP int ASN1CALL encode_BaseDistance(unsigned char *, size_t, const BaseDistance *, size_t *); ASN1EXP size_t ASN1CALL length_BaseDistance(const BaseDistance *); ASN1EXP int ASN1CALL copy_BaseDistance (const BaseDistance *, BaseDistance *); ASN1EXP void ASN1CALL free_BaseDistance (BaseDistance *); /* GeneralSubtree ::= SEQUENCE { base GeneralName, minimum [0] IMPLICIT INTEGER OPTIONAL, maximum [1] IMPLICIT INTEGER OPTIONAL, } */ typedef struct GeneralSubtree { GeneralName base; heim_integer *minimum; heim_integer *maximum; } GeneralSubtree; ASN1EXP int ASN1CALL decode_GeneralSubtree(const unsigned char *, size_t, GeneralSubtree *, size_t *); ASN1EXP int ASN1CALL encode_GeneralSubtree(unsigned char *, size_t, const GeneralSubtree *, size_t *); ASN1EXP size_t ASN1CALL length_GeneralSubtree(const GeneralSubtree *); ASN1EXP int ASN1CALL copy_GeneralSubtree (const GeneralSubtree *, GeneralSubtree *); ASN1EXP void ASN1CALL free_GeneralSubtree (GeneralSubtree *); /* GeneralSubtrees ::= SEQUENCE OF GeneralSubtree */ typedef struct GeneralSubtrees { unsigned int len; GeneralSubtree *val; } GeneralSubtrees; ASN1EXP int ASN1CALL decode_GeneralSubtrees(const unsigned char *, size_t, GeneralSubtrees *, size_t *); ASN1EXP int ASN1CALL encode_GeneralSubtrees(unsigned char *, size_t, const GeneralSubtrees *, size_t *); ASN1EXP size_t ASN1CALL length_GeneralSubtrees(const GeneralSubtrees *); ASN1EXP int ASN1CALL copy_GeneralSubtrees (const GeneralSubtrees *, GeneralSubtrees *); ASN1EXP void ASN1CALL free_GeneralSubtrees (GeneralSubtrees *); /* NameConstraints ::= SEQUENCE { permittedSubtrees [0] IMPLICIT SEQUENCE OF GeneralSubtree OPTIONAL, excludedSubtrees [1] IMPLICIT SEQUENCE OF GeneralSubtree OPTIONAL, } */ typedef struct NameConstraints { struct NameConstraints_permittedSubtrees { unsigned int len; GeneralSubtree *val; } *permittedSubtrees; struct NameConstraints_excludedSubtrees { unsigned int len; GeneralSubtree *val; } *excludedSubtrees; } NameConstraints; ASN1EXP int ASN1CALL decode_NameConstraints(const unsigned char *, size_t, NameConstraints *, size_t *); ASN1EXP int ASN1CALL encode_NameConstraints(unsigned char *, size_t, const NameConstraints *, size_t *); ASN1EXP size_t ASN1CALL length_NameConstraints(const NameConstraints *); ASN1EXP int ASN1CALL copy_NameConstraints (const NameConstraints *, NameConstraints *); ASN1EXP void ASN1CALL free_NameConstraints (NameConstraints *); /* OBJECT IDENTIFIER id-x509-ce-privateKeyUsagePeriod ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(16) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_privateKeyUsagePeriod; #define ASN1_OID_ID_X509_CE_PRIVATEKEYUSAGEPERIOD (&asn1_oid_id_x509_ce_privateKeyUsagePeriod) /* OBJECT IDENTIFIER id-x509-ce-certificatePolicies ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(32) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_certificatePolicies; #define ASN1_OID_ID_X509_CE_CERTIFICATEPOLICIES (&asn1_oid_id_x509_ce_certificatePolicies) /* OBJECT IDENTIFIER id-x509-ce-policyMappings ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(33) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_policyMappings; #define ASN1_OID_ID_X509_CE_POLICYMAPPINGS (&asn1_oid_id_x509_ce_policyMappings) /* OBJECT IDENTIFIER id-x509-ce-subjectAltName ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(17) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_subjectAltName; #define ASN1_OID_ID_X509_CE_SUBJECTALTNAME (&asn1_oid_id_x509_ce_subjectAltName) /* OBJECT IDENTIFIER id-x509-ce-issuerAltName ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(18) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_issuerAltName; #define ASN1_OID_ID_X509_CE_ISSUERALTNAME (&asn1_oid_id_x509_ce_issuerAltName) /* OBJECT IDENTIFIER id-x509-ce-subjectDirectoryAttributes ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(9) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_subjectDirectoryAttributes; #define ASN1_OID_ID_X509_CE_SUBJECTDIRECTORYATTRIBUTES (&asn1_oid_id_x509_ce_subjectDirectoryAttributes) /* OBJECT IDENTIFIER id-x509-ce-policyConstraints ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(36) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_policyConstraints; #define ASN1_OID_ID_X509_CE_POLICYCONSTRAINTS (&asn1_oid_id_x509_ce_policyConstraints) /* OBJECT IDENTIFIER id-x509-ce-extKeyUsage ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(37) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_extKeyUsage; #define ASN1_OID_ID_X509_CE_EXTKEYUSAGE (&asn1_oid_id_x509_ce_extKeyUsage) /* ExtKeyUsage ::= SEQUENCE OF OBJECT IDENTIFIER */ typedef struct ExtKeyUsage { unsigned int len; heim_oid *val; } ExtKeyUsage; ASN1EXP int ASN1CALL decode_ExtKeyUsage(const unsigned char *, size_t, ExtKeyUsage *, size_t *); ASN1EXP int ASN1CALL encode_ExtKeyUsage(unsigned char *, size_t, const ExtKeyUsage *, size_t *); ASN1EXP size_t ASN1CALL length_ExtKeyUsage(const ExtKeyUsage *); ASN1EXP int ASN1CALL copy_ExtKeyUsage (const ExtKeyUsage *, ExtKeyUsage *); ASN1EXP void ASN1CALL free_ExtKeyUsage (ExtKeyUsage *); /* OBJECT IDENTIFIER id-x509-ce-cRLDistributionPoints ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(31) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_cRLDistributionPoints; #define ASN1_OID_ID_X509_CE_CRLDISTRIBUTIONPOINTS (&asn1_oid_id_x509_ce_cRLDistributionPoints) /* OBJECT IDENTIFIER id-x509-ce-deltaCRLIndicator ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(27) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_deltaCRLIndicator; #define ASN1_OID_ID_X509_CE_DELTACRLINDICATOR (&asn1_oid_id_x509_ce_deltaCRLIndicator) /* OBJECT IDENTIFIER id-x509-ce-issuingDistributionPoint ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(28) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_issuingDistributionPoint; #define ASN1_OID_ID_X509_CE_ISSUINGDISTRIBUTIONPOINT (&asn1_oid_id_x509_ce_issuingDistributionPoint) /* OBJECT IDENTIFIER id-x509-ce-holdInstructionCode ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(23) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_holdInstructionCode; #define ASN1_OID_ID_X509_CE_HOLDINSTRUCTIONCODE (&asn1_oid_id_x509_ce_holdInstructionCode) /* OBJECT IDENTIFIER id-x509-ce-invalidityDate ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(24) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_invalidityDate; #define ASN1_OID_ID_X509_CE_INVALIDITYDATE (&asn1_oid_id_x509_ce_invalidityDate) /* OBJECT IDENTIFIER id-x509-ce-certificateIssuer ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(29) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_certificateIssuer; #define ASN1_OID_ID_X509_CE_CERTIFICATEISSUER (&asn1_oid_id_x509_ce_certificateIssuer) /* OBJECT IDENTIFIER id-x509-ce-inhibitAnyPolicy ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(54) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_inhibitAnyPolicy; #define ASN1_OID_ID_X509_CE_INHIBITANYPOLICY (&asn1_oid_id_x509_ce_inhibitAnyPolicy) /* DistributionPointReasonFlags ::= BIT STRING { unused(0), keyCompromise(1), cACompromise(2), affiliationChanged(3), superseded(4), cessationOfOperation(5), certificateHold(6), privilegeWithdrawn(7), aACompromise(8) } */ typedef struct DistributionPointReasonFlags { unsigned int unused:1; unsigned int keyCompromise:1; unsigned int cACompromise:1; unsigned int affiliationChanged:1; unsigned int superseded:1; unsigned int cessationOfOperation:1; unsigned int certificateHold:1; unsigned int privilegeWithdrawn:1; unsigned int aACompromise:1; unsigned int _unused9:1; unsigned int _unused10:1; unsigned int _unused11:1; unsigned int _unused12:1; unsigned int _unused13:1; unsigned int _unused14:1; unsigned int _unused15:1; unsigned int _unused16:1; unsigned int _unused17:1; unsigned int _unused18:1; unsigned int _unused19:1; unsigned int _unused20:1; unsigned int _unused21:1; unsigned int _unused22:1; unsigned int _unused23:1; unsigned int _unused24:1; unsigned int _unused25:1; unsigned int _unused26:1; unsigned int _unused27:1; unsigned int _unused28:1; unsigned int _unused29:1; unsigned int _unused30:1; unsigned int _unused31:1; } DistributionPointReasonFlags; unsigned DistributionPointReasonFlags2int(DistributionPointReasonFlags); DistributionPointReasonFlags int2DistributionPointReasonFlags(unsigned); const struct units * asn1_DistributionPointReasonFlags_units(void); ASN1EXP int ASN1CALL decode_DistributionPointReasonFlags(const unsigned char *, size_t, DistributionPointReasonFlags *, size_t *); ASN1EXP int ASN1CALL encode_DistributionPointReasonFlags(unsigned char *, size_t, const DistributionPointReasonFlags *, size_t *); ASN1EXP size_t ASN1CALL length_DistributionPointReasonFlags(const DistributionPointReasonFlags *); ASN1EXP int ASN1CALL copy_DistributionPointReasonFlags (const DistributionPointReasonFlags *, DistributionPointReasonFlags *); ASN1EXP void ASN1CALL free_DistributionPointReasonFlags (DistributionPointReasonFlags *); /* DistributionPointName ::= CHOICE { fullName [0] IMPLICIT SEQUENCE OF GeneralName, nameRelativeToCRLIssuer [1] RelativeDistinguishedName, } */ typedef struct DistributionPointName { enum DistributionPointName_enum { choice_DistributionPointName_fullName = 1, choice_DistributionPointName_nameRelativeToCRLIssuer } element; union { struct DistributionPointName_fullName { unsigned int len; GeneralName *val; } fullName; RelativeDistinguishedName nameRelativeToCRLIssuer; } u; } DistributionPointName; ASN1EXP int ASN1CALL decode_DistributionPointName(const unsigned char *, size_t, DistributionPointName *, size_t *); ASN1EXP int ASN1CALL encode_DistributionPointName(unsigned char *, size_t, const DistributionPointName *, size_t *); ASN1EXP size_t ASN1CALL length_DistributionPointName(const DistributionPointName *); ASN1EXP int ASN1CALL copy_DistributionPointName (const DistributionPointName *, DistributionPointName *); ASN1EXP void ASN1CALL free_DistributionPointName (DistributionPointName *); /* DistributionPoint ::= SEQUENCE { distributionPoint [0] IMPLICIT heim_any OPTIONAL, reasons [1] IMPLICIT heim_any OPTIONAL, cRLIssuer [2] IMPLICIT heim_any OPTIONAL, } */ typedef struct DistributionPoint { heim_any *distributionPoint; heim_any *reasons; heim_any *cRLIssuer; } DistributionPoint; ASN1EXP int ASN1CALL decode_DistributionPoint(const unsigned char *, size_t, DistributionPoint *, size_t *); ASN1EXP int ASN1CALL encode_DistributionPoint(unsigned char *, size_t, const DistributionPoint *, size_t *); ASN1EXP size_t ASN1CALL length_DistributionPoint(const DistributionPoint *); ASN1EXP int ASN1CALL copy_DistributionPoint (const DistributionPoint *, DistributionPoint *); ASN1EXP void ASN1CALL free_DistributionPoint (DistributionPoint *); /* CRLDistributionPoints ::= SEQUENCE OF DistributionPoint */ typedef struct CRLDistributionPoints { unsigned int len; DistributionPoint *val; } CRLDistributionPoints; ASN1EXP int ASN1CALL add_CRLDistributionPoints (CRLDistributionPoints *, const DistributionPoint *); ASN1EXP int ASN1CALL remove_CRLDistributionPoints (CRLDistributionPoints *, unsigned int); ASN1EXP int ASN1CALL decode_CRLDistributionPoints(const unsigned char *, size_t, CRLDistributionPoints *, size_t *); ASN1EXP int ASN1CALL encode_CRLDistributionPoints(unsigned char *, size_t, const CRLDistributionPoints *, size_t *); ASN1EXP size_t ASN1CALL length_CRLDistributionPoints(const CRLDistributionPoints *); ASN1EXP int ASN1CALL copy_CRLDistributionPoints (const CRLDistributionPoints *, CRLDistributionPoints *); ASN1EXP void ASN1CALL free_CRLDistributionPoints (CRLDistributionPoints *); /* DSASigValue ::= SEQUENCE { r INTEGER, s INTEGER, } */ typedef struct DSASigValue { heim_integer r; heim_integer s; } DSASigValue; ASN1EXP int ASN1CALL decode_DSASigValue(const unsigned char *, size_t, DSASigValue *, size_t *); ASN1EXP int ASN1CALL encode_DSASigValue(unsigned char *, size_t, const DSASigValue *, size_t *); ASN1EXP size_t ASN1CALL length_DSASigValue(const DSASigValue *); ASN1EXP int ASN1CALL copy_DSASigValue (const DSASigValue *, DSASigValue *); ASN1EXP void ASN1CALL free_DSASigValue (DSASigValue *); /* DSAPublicKey ::= INTEGER */ typedef heim_integer DSAPublicKey; ASN1EXP int ASN1CALL decode_DSAPublicKey(const unsigned char *, size_t, DSAPublicKey *, size_t *); ASN1EXP int ASN1CALL encode_DSAPublicKey(unsigned char *, size_t, const DSAPublicKey *, size_t *); ASN1EXP size_t ASN1CALL length_DSAPublicKey(const DSAPublicKey *); ASN1EXP int ASN1CALL copy_DSAPublicKey (const DSAPublicKey *, DSAPublicKey *); ASN1EXP void ASN1CALL free_DSAPublicKey (DSAPublicKey *); /* DSAParams ::= SEQUENCE { p INTEGER, q INTEGER, g INTEGER, } */ typedef struct DSAParams { heim_integer p; heim_integer q; heim_integer g; } DSAParams; ASN1EXP int ASN1CALL decode_DSAParams(const unsigned char *, size_t, DSAParams *, size_t *); ASN1EXP int ASN1CALL encode_DSAParams(unsigned char *, size_t, const DSAParams *, size_t *); ASN1EXP size_t ASN1CALL length_DSAParams(const DSAParams *); ASN1EXP int ASN1CALL copy_DSAParams (const DSAParams *, DSAParams *); ASN1EXP void ASN1CALL free_DSAParams (DSAParams *); /* ECPoint ::= OCTET STRING */ typedef heim_octet_string ECPoint; ASN1EXP int ASN1CALL decode_ECPoint(const unsigned char *, size_t, ECPoint *, size_t *); ASN1EXP int ASN1CALL encode_ECPoint(unsigned char *, size_t, const ECPoint *, size_t *); ASN1EXP size_t ASN1CALL length_ECPoint(const ECPoint *); ASN1EXP int ASN1CALL copy_ECPoint (const ECPoint *, ECPoint *); ASN1EXP void ASN1CALL free_ECPoint (ECPoint *); /* ECParameters ::= CHOICE { namedCurve OBJECT IDENTIFIER, } */ typedef struct ECParameters { enum ECParameters_enum { choice_ECParameters_namedCurve = 1 } element; union { heim_oid namedCurve; } u; } ECParameters; ASN1EXP int ASN1CALL decode_ECParameters(const unsigned char *, size_t, ECParameters *, size_t *); ASN1EXP int ASN1CALL encode_ECParameters(unsigned char *, size_t, const ECParameters *, size_t *); ASN1EXP size_t ASN1CALL length_ECParameters(const ECParameters *); ASN1EXP int ASN1CALL copy_ECParameters (const ECParameters *, ECParameters *); ASN1EXP void ASN1CALL free_ECParameters (ECParameters *); /* ECDSA-Sig-Value ::= SEQUENCE { r INTEGER, s INTEGER, } */ typedef struct ECDSA_Sig_Value { heim_integer r; heim_integer s; } ECDSA_Sig_Value; ASN1EXP int ASN1CALL decode_ECDSA_Sig_Value(const unsigned char *, size_t, ECDSA_Sig_Value *, size_t *); ASN1EXP int ASN1CALL encode_ECDSA_Sig_Value(unsigned char *, size_t, const ECDSA_Sig_Value *, size_t *); ASN1EXP size_t ASN1CALL length_ECDSA_Sig_Value(const ECDSA_Sig_Value *); ASN1EXP int ASN1CALL copy_ECDSA_Sig_Value (const ECDSA_Sig_Value *, ECDSA_Sig_Value *); ASN1EXP void ASN1CALL free_ECDSA_Sig_Value (ECDSA_Sig_Value *); /* RSAPublicKey ::= SEQUENCE { modulus INTEGER, publicExponent INTEGER, } */ typedef struct RSAPublicKey { heim_integer modulus; heim_integer publicExponent; } RSAPublicKey; ASN1EXP int ASN1CALL decode_RSAPublicKey(const unsigned char *, size_t, RSAPublicKey *, size_t *); ASN1EXP int ASN1CALL encode_RSAPublicKey(unsigned char *, size_t, const RSAPublicKey *, size_t *); ASN1EXP size_t ASN1CALL length_RSAPublicKey(const RSAPublicKey *); ASN1EXP int ASN1CALL copy_RSAPublicKey (const RSAPublicKey *, RSAPublicKey *); ASN1EXP void ASN1CALL free_RSAPublicKey (RSAPublicKey *); /* RSAPrivateKey ::= SEQUENCE { version INTEGER (0..4294967295), modulus INTEGER, publicExponent INTEGER, privateExponent INTEGER, prime1 INTEGER, prime2 INTEGER, exponent1 INTEGER, exponent2 INTEGER, coefficient INTEGER, } */ typedef struct RSAPrivateKey { unsigned int version; heim_integer modulus; heim_integer publicExponent; heim_integer privateExponent; heim_integer prime1; heim_integer prime2; heim_integer exponent1; heim_integer exponent2; heim_integer coefficient; } RSAPrivateKey; ASN1EXP int ASN1CALL decode_RSAPrivateKey(const unsigned char *, size_t, RSAPrivateKey *, size_t *); ASN1EXP int ASN1CALL encode_RSAPrivateKey(unsigned char *, size_t, const RSAPrivateKey *, size_t *); ASN1EXP size_t ASN1CALL length_RSAPrivateKey(const RSAPrivateKey *); ASN1EXP int ASN1CALL copy_RSAPrivateKey (const RSAPrivateKey *, RSAPrivateKey *); ASN1EXP void ASN1CALL free_RSAPrivateKey (RSAPrivateKey *); /* DigestInfo ::= SEQUENCE { digestAlgorithm AlgorithmIdentifier, digest OCTET STRING, } */ typedef struct DigestInfo { AlgorithmIdentifier digestAlgorithm; heim_octet_string digest; } DigestInfo; ASN1EXP int ASN1CALL decode_DigestInfo(const unsigned char *, size_t, DigestInfo *, size_t *); ASN1EXP int ASN1CALL encode_DigestInfo(unsigned char *, size_t, const DigestInfo *, size_t *); ASN1EXP size_t ASN1CALL length_DigestInfo(const DigestInfo *); ASN1EXP int ASN1CALL copy_DigestInfo (const DigestInfo *, DigestInfo *); ASN1EXP void ASN1CALL free_DigestInfo (DigestInfo *); /* TBSCRLCertList ::= SEQUENCE { version Version OPTIONAL, signature AlgorithmIdentifier, issuer Name, thisUpdate Time, nextUpdate Time OPTIONAL, revokedCertificates SEQUENCE OF SEQUENCE { userCertificate CertificateSerialNumber, revocationDate Time, crlEntryExtensions Extensions OPTIONAL, } OPTIONAL, crlExtensions [0] Extensions OPTIONAL, } */ typedef struct TBSCRLCertList { heim_octet_string _save; Version *version; AlgorithmIdentifier signature; Name issuer; Time thisUpdate; Time *nextUpdate; struct TBSCRLCertList_revokedCertificates { unsigned int len; struct TBSCRLCertList_revokedCertificates_val { CertificateSerialNumber userCertificate; Time revocationDate; Extensions *crlEntryExtensions; } *val; } *revokedCertificates; Extensions *crlExtensions; } TBSCRLCertList; ASN1EXP int ASN1CALL decode_TBSCRLCertList(const unsigned char *, size_t, TBSCRLCertList *, size_t *); ASN1EXP int ASN1CALL encode_TBSCRLCertList(unsigned char *, size_t, const TBSCRLCertList *, size_t *); ASN1EXP size_t ASN1CALL length_TBSCRLCertList(const TBSCRLCertList *); ASN1EXP int ASN1CALL copy_TBSCRLCertList (const TBSCRLCertList *, TBSCRLCertList *); ASN1EXP void ASN1CALL free_TBSCRLCertList (TBSCRLCertList *); /* CRLCertificateList ::= SEQUENCE { tbsCertList TBSCRLCertList, signatureAlgorithm AlgorithmIdentifier, signatureValue BIT STRING { }, } */ typedef struct CRLCertificateList { TBSCRLCertList tbsCertList; AlgorithmIdentifier signatureAlgorithm; heim_bit_string signatureValue; } CRLCertificateList; ASN1EXP int ASN1CALL decode_CRLCertificateList(const unsigned char *, size_t, CRLCertificateList *, size_t *); ASN1EXP int ASN1CALL encode_CRLCertificateList(unsigned char *, size_t, const CRLCertificateList *, size_t *); ASN1EXP size_t ASN1CALL length_CRLCertificateList(const CRLCertificateList *); ASN1EXP int ASN1CALL copy_CRLCertificateList (const CRLCertificateList *, CRLCertificateList *); ASN1EXP void ASN1CALL free_CRLCertificateList (CRLCertificateList *); /* OBJECT IDENTIFIER id-x509-ce-cRLNumber ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(20) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_cRLNumber; #define ASN1_OID_ID_X509_CE_CRLNUMBER (&asn1_oid_id_x509_ce_cRLNumber) /* OBJECT IDENTIFIER id-x509-ce-freshestCRL ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(46) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_freshestCRL; #define ASN1_OID_ID_X509_CE_FRESHESTCRL (&asn1_oid_id_x509_ce_freshestCRL) /* OBJECT IDENTIFIER id-x509-ce-cRLReason ::= { joint-iso-ccitt(2) ds(5) label-less(29) label-less(21) } */ extern ASN1EXP const heim_oid asn1_oid_id_x509_ce_cRLReason; #define ASN1_OID_ID_X509_CE_CRLREASON (&asn1_oid_id_x509_ce_cRLReason) /* CRLReason ::= INTEGER { unspecified(0), keyCompromise(1), cACompromise(2), affiliationChanged(3), superseded(4), cessationOfOperation(5), certificateHold(6), removeFromCRL(8), privilegeWithdrawn(9), aACompromise(10) } */ typedef enum CRLReason { unspecified = 0, keyCompromise = 1, cACompromise = 2, affiliationChanged = 3, superseded = 4, cessationOfOperation = 5, certificateHold = 6, removeFromCRL = 8, privilegeWithdrawn = 9, aACompromise = 10 } CRLReason; ASN1EXP int ASN1CALL decode_CRLReason(const unsigned char *, size_t, CRLReason *, size_t *); ASN1EXP int ASN1CALL encode_CRLReason(unsigned char *, size_t, const CRLReason *, size_t *); ASN1EXP size_t ASN1CALL length_CRLReason(const CRLReason *); ASN1EXP int ASN1CALL copy_CRLReason (const CRLReason *, CRLReason *); ASN1EXP void ASN1CALL free_CRLReason (CRLReason *); /* PKIXXmppAddr ::= UTF8String */ typedef heim_utf8_string PKIXXmppAddr; ASN1EXP int ASN1CALL decode_PKIXXmppAddr(const unsigned char *, size_t, PKIXXmppAddr *, size_t *); ASN1EXP int ASN1CALL encode_PKIXXmppAddr(unsigned char *, size_t, const PKIXXmppAddr *, size_t *); ASN1EXP size_t ASN1CALL length_PKIXXmppAddr(const PKIXXmppAddr *); ASN1EXP int ASN1CALL copy_PKIXXmppAddr (const PKIXXmppAddr *, PKIXXmppAddr *); ASN1EXP void ASN1CALL free_PKIXXmppAddr (PKIXXmppAddr *); /* OBJECT IDENTIFIER id-pkix ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix; #define ASN1_OID_ID_PKIX (&asn1_oid_id_pkix) /* OBJECT IDENTIFIER id-pkix-on ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(8) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix_on; #define ASN1_OID_ID_PKIX_ON (&asn1_oid_id_pkix_on) /* OBJECT IDENTIFIER id-pkix-on-xmppAddr ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(8) label-less(5) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix_on_xmppAddr; #define ASN1_OID_ID_PKIX_ON_XMPPADDR (&asn1_oid_id_pkix_on_xmppAddr) /* OBJECT IDENTIFIER id-pkix-on-dnsSRV ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(8) label-less(7) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix_on_dnsSRV; #define ASN1_OID_ID_PKIX_ON_DNSSRV (&asn1_oid_id_pkix_on_dnsSRV) /* OBJECT IDENTIFIER id-pkix-kp ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(3) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix_kp; #define ASN1_OID_ID_PKIX_KP (&asn1_oid_id_pkix_kp) /* OBJECT IDENTIFIER id-pkix-kp-serverAuth ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(3) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix_kp_serverAuth; #define ASN1_OID_ID_PKIX_KP_SERVERAUTH (&asn1_oid_id_pkix_kp_serverAuth) /* OBJECT IDENTIFIER id-pkix-kp-clientAuth ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(3) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix_kp_clientAuth; #define ASN1_OID_ID_PKIX_KP_CLIENTAUTH (&asn1_oid_id_pkix_kp_clientAuth) /* OBJECT IDENTIFIER id-pkix-kp-emailProtection ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(3) label-less(4) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix_kp_emailProtection; #define ASN1_OID_ID_PKIX_KP_EMAILPROTECTION (&asn1_oid_id_pkix_kp_emailProtection) /* OBJECT IDENTIFIER id-pkix-kp-timeStamping ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(3) label-less(8) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix_kp_timeStamping; #define ASN1_OID_ID_PKIX_KP_TIMESTAMPING (&asn1_oid_id_pkix_kp_timeStamping) /* OBJECT IDENTIFIER id-pkix-kp-OCSPSigning ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(3) label-less(9) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix_kp_OCSPSigning; #define ASN1_OID_ID_PKIX_KP_OCSPSIGNING (&asn1_oid_id_pkix_kp_OCSPSigning) /* OBJECT IDENTIFIER id-pkix-pe ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix_pe; #define ASN1_OID_ID_PKIX_PE (&asn1_oid_id_pkix_pe) /* OBJECT IDENTIFIER id-pkix-pe-authorityInfoAccess ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(1) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix_pe_authorityInfoAccess; #define ASN1_OID_ID_PKIX_PE_AUTHORITYINFOACCESS (&asn1_oid_id_pkix_pe_authorityInfoAccess) /* AccessDescription ::= SEQUENCE { accessMethod OBJECT IDENTIFIER, accessLocation GeneralName, } */ typedef struct AccessDescription { heim_oid accessMethod; GeneralName accessLocation; } AccessDescription; ASN1EXP int ASN1CALL decode_AccessDescription(const unsigned char *, size_t, AccessDescription *, size_t *); ASN1EXP int ASN1CALL encode_AccessDescription(unsigned char *, size_t, const AccessDescription *, size_t *); ASN1EXP size_t ASN1CALL length_AccessDescription(const AccessDescription *); ASN1EXP int ASN1CALL copy_AccessDescription (const AccessDescription *, AccessDescription *); ASN1EXP void ASN1CALL free_AccessDescription (AccessDescription *); /* AuthorityInfoAccessSyntax ::= SEQUENCE OF AccessDescription */ typedef struct AuthorityInfoAccessSyntax { unsigned int len; AccessDescription *val; } AuthorityInfoAccessSyntax; ASN1EXP int ASN1CALL decode_AuthorityInfoAccessSyntax(const unsigned char *, size_t, AuthorityInfoAccessSyntax *, size_t *); ASN1EXP int ASN1CALL encode_AuthorityInfoAccessSyntax(unsigned char *, size_t, const AuthorityInfoAccessSyntax *, size_t *); ASN1EXP size_t ASN1CALL length_AuthorityInfoAccessSyntax(const AuthorityInfoAccessSyntax *); ASN1EXP int ASN1CALL copy_AuthorityInfoAccessSyntax (const AuthorityInfoAccessSyntax *, AuthorityInfoAccessSyntax *); ASN1EXP void ASN1CALL free_AuthorityInfoAccessSyntax (AuthorityInfoAccessSyntax *); /* OBJECT IDENTIFIER id-pkix-pe-proxyCertInfo ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(1) label-less(14) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix_pe_proxyCertInfo; #define ASN1_OID_ID_PKIX_PE_PROXYCERTINFO (&asn1_oid_id_pkix_pe_proxyCertInfo) /* OBJECT IDENTIFIER id-pkix-ppl ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(21) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix_ppl; #define ASN1_OID_ID_PKIX_PPL (&asn1_oid_id_pkix_ppl) /* OBJECT IDENTIFIER id-pkix-ppl-anyLanguage ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(21) label-less(0) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix_ppl_anyLanguage; #define ASN1_OID_ID_PKIX_PPL_ANYLANGUAGE (&asn1_oid_id_pkix_ppl_anyLanguage) /* OBJECT IDENTIFIER id-pkix-ppl-inheritAll ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(21) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix_ppl_inheritAll; #define ASN1_OID_ID_PKIX_PPL_INHERITALL (&asn1_oid_id_pkix_ppl_inheritAll) /* OBJECT IDENTIFIER id-pkix-ppl-independent ::= { iso(1) identified-organization(3) dod(6) internet(1) security(5) mechanisms(5) pkix(7) label-less(21) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_pkix_ppl_independent; #define ASN1_OID_ID_PKIX_PPL_INDEPENDENT (&asn1_oid_id_pkix_ppl_independent) /* ProxyPolicy ::= SEQUENCE { policyLanguage OBJECT IDENTIFIER, policy OCTET STRING OPTIONAL, } */ typedef struct ProxyPolicy { heim_oid policyLanguage; heim_octet_string *policy; } ProxyPolicy; ASN1EXP int ASN1CALL decode_ProxyPolicy(const unsigned char *, size_t, ProxyPolicy *, size_t *); ASN1EXP int ASN1CALL encode_ProxyPolicy(unsigned char *, size_t, const ProxyPolicy *, size_t *); ASN1EXP size_t ASN1CALL length_ProxyPolicy(const ProxyPolicy *); ASN1EXP int ASN1CALL copy_ProxyPolicy (const ProxyPolicy *, ProxyPolicy *); ASN1EXP void ASN1CALL free_ProxyPolicy (ProxyPolicy *); /* ProxyCertInfo ::= SEQUENCE { pCPathLenConstraint INTEGER (0..4294967295) OPTIONAL, proxyPolicy ProxyPolicy, } */ typedef struct ProxyCertInfo { unsigned int *pCPathLenConstraint; ProxyPolicy proxyPolicy; } ProxyCertInfo; ASN1EXP int ASN1CALL decode_ProxyCertInfo(const unsigned char *, size_t, ProxyCertInfo *, size_t *); ASN1EXP int ASN1CALL encode_ProxyCertInfo(unsigned char *, size_t, const ProxyCertInfo *, size_t *); ASN1EXP size_t ASN1CALL length_ProxyCertInfo(const ProxyCertInfo *); ASN1EXP int ASN1CALL copy_ProxyCertInfo (const ProxyCertInfo *, ProxyCertInfo *); ASN1EXP void ASN1CALL free_ProxyCertInfo (ProxyCertInfo *); /* OBJECT IDENTIFIER id-uspkicommon-card-id ::= { label-less(2) label-less(16) label-less(840) label-less(1) label-less(101) label-less(3) label-less(6) label-less(6) } */ extern ASN1EXP const heim_oid asn1_oid_id_uspkicommon_card_id; #define ASN1_OID_ID_USPKICOMMON_CARD_ID (&asn1_oid_id_uspkicommon_card_id) /* OBJECT IDENTIFIER id-uspkicommon-piv-interim ::= { label-less(2) label-less(16) label-less(840) label-less(1) label-less(101) label-less(3) label-less(6) label-less(9) label-less(1) } */ extern ASN1EXP const heim_oid asn1_oid_id_uspkicommon_piv_interim; #define ASN1_OID_ID_USPKICOMMON_PIV_INTERIM (&asn1_oid_id_uspkicommon_piv_interim) /* OBJECT IDENTIFIER id-netscape ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) netscape(113730) } */ extern ASN1EXP const heim_oid asn1_oid_id_netscape; #define ASN1_OID_ID_NETSCAPE (&asn1_oid_id_netscape) /* OBJECT IDENTIFIER id-netscape-cert-comment ::= { joint-iso-itu-t(2) country(16) us(840) organization(1) netscape(113730) label-less(1) label-less(13) } */ extern ASN1EXP const heim_oid asn1_oid_id_netscape_cert_comment; #define ASN1_OID_ID_NETSCAPE_CERT_COMMENT (&asn1_oid_id_netscape_cert_comment) /* OBJECT IDENTIFIER id-ms-cert-enroll-domaincontroller ::= { label-less(1) label-less(3) label-less(6) label-less(1) label-less(4) label-less(1) label-less(311) label-less(20) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_ms_cert_enroll_domaincontroller; #define ASN1_OID_ID_MS_CERT_ENROLL_DOMAINCONTROLLER (&asn1_oid_id_ms_cert_enroll_domaincontroller) /* OBJECT IDENTIFIER id-ms-client-authentication ::= { label-less(1) label-less(3) label-less(6) label-less(1) label-less(5) label-less(5) label-less(7) label-less(3) label-less(2) } */ extern ASN1EXP const heim_oid asn1_oid_id_ms_client_authentication; #define ASN1_OID_ID_MS_CLIENT_AUTHENTICATION (&asn1_oid_id_ms_client_authentication) #endif /* __rfc2459_asn1_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/roken-common.h000066400000000000000000000302501505521762700233710ustar00rootroot00000000000000/* * Copyright (c) 1995 - 2005 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef __ROKEN_COMMON_H__ #define __ROKEN_COMMON_H__ #ifndef ROKEN_LIB_FUNCTION #ifdef _WIN32 #define ROKEN_LIB_FUNCTION #define ROKEN_LIB_CALL __cdecl #else #define ROKEN_LIB_FUNCTION #define ROKEN_LIB_CALL #endif #endif #ifdef __cplusplus #define ROKEN_CPP_START extern "C" { #define ROKEN_CPP_END } #else #define ROKEN_CPP_START #define ROKEN_CPP_END #endif #ifndef INADDR_NONE #define INADDR_NONE 0xffffffff #endif #ifndef INADDR_LOOPBACK #define INADDR_LOOPBACK 0x7f000001 #endif #ifndef SOMAXCONN #define SOMAXCONN 5 #endif #ifndef STDIN_FILENO #define STDIN_FILENO 0 #endif #ifndef STDOUT_FILENO #define STDOUT_FILENO 1 #endif #ifndef STDERR_FILENO #define STDERR_FILENO 2 #endif #ifndef max #define max(a,b) (((a)>(b))?(a):(b)) #endif #ifndef min #define min(a,b) (((a)<(b))?(a):(b)) #endif #ifndef TRUE #define TRUE 1 #endif #ifndef FALSE #define FALSE 0 #endif #ifndef LOG_DAEMON #define openlog(id,option,facility) openlog((id),(option)) #define LOG_DAEMON 0 #endif #ifndef LOG_ODELAY #define LOG_ODELAY 0 #endif #ifndef LOG_NDELAY #define LOG_NDELAY 0x08 #endif #ifndef LOG_CONS #define LOG_CONS 0 #endif #ifndef LOG_AUTH #define LOG_AUTH 0 #endif #ifndef LOG_AUTHPRIV #define LOG_AUTHPRIV LOG_AUTH #endif #ifndef F_OK #define F_OK 0 #endif #ifndef O_ACCMODE #define O_ACCMODE 003 #endif #ifndef O_NOFOLLOW #define O_NOFOLLOW 0 #endif #ifdef _WIN32 #define _PATH_DEVNULL "\\\\.\\NUL" #else #ifndef _PATH_DEV #define _PATH_DEV "/dev/" #endif #ifndef _PATH_DEVNULL #define _PATH_DEVNULL "/dev/null" #endif #ifndef _PATH_HEQUIV #define _PATH_HEQUIV "/etc/hosts.equiv" #endif #ifndef _PATH_VARRUN #define _PATH_VARRUN "/var/run/" #endif #ifndef _PATH_BSHELL #define _PATH_BSHELL "/bin/sh" #endif #ifndef MAXPATHLEN #define MAXPATHLEN (1024+4) #endif #endif /* !_WIN32 */ #ifndef PATH_MAX #ifdef MAX_PATH #define PATH_MAX MAX_PATH #else #define PATH_MAX 4096 #endif #endif #ifndef RETSIGTYPE #define RETSIGTYPE void #endif #ifndef SIG_ERR #define SIG_ERR ((RETSIGTYPE (*)(int))-1) #endif /* * error code for getipnodeby{name,addr} */ #ifndef HOST_NOT_FOUND #define HOST_NOT_FOUND 1 #endif #ifndef TRY_AGAIN #define TRY_AGAIN 2 #endif #ifndef NO_RECOVERY #define NO_RECOVERY 3 #endif #ifndef NO_DATA #define NO_DATA 4 #endif #ifndef NO_ADDRESS #define NO_ADDRESS NO_DATA #endif /* * error code for getaddrinfo */ #ifndef EAI_NOERROR #define EAI_NOERROR 0 /* no error */ #endif #ifndef EAI_NONAME #define EAI_ADDRFAMILY 1 /* address family for nodename not supported */ #define EAI_AGAIN 2 /* temporary failure in name resolution */ #define EAI_BADFLAGS 3 /* invalid value for ai_flags */ #define EAI_FAIL 4 /* non-recoverable failure in name resolution */ #define EAI_FAMILY 5 /* ai_family not supported */ #define EAI_MEMORY 6 /* memory allocation failure */ #define EAI_NODATA 7 /* no address associated with nodename */ #define EAI_NONAME 8 /* nodename nor servname provided, or not known */ #define EAI_SERVICE 9 /* servname not supported for ai_socktype */ #define EAI_SOCKTYPE 10 /* ai_socktype not supported */ #define EAI_SYSTEM 11 /* system error returned in errno */ #endif /* EAI_NONAME */ /* flags for getaddrinfo() */ #ifndef AI_PASSIVE #define AI_PASSIVE 0x01 #define AI_CANONNAME 0x02 #endif /* AI_PASSIVE */ #ifndef AI_NUMERICHOST #define AI_NUMERICHOST 0x04 #endif #ifndef AI_NUMERICSERV #define AI_NUMERICSERV 0x08 #endif /* flags for getnameinfo() */ #ifndef NI_DGRAM #define NI_DGRAM 0x01 #define NI_NAMEREQD 0x02 #define NI_NOFQDN 0x04 #define NI_NUMERICHOST 0x08 #define NI_NUMERICSERV 0x10 #endif /* * constants for getnameinfo */ #ifndef NI_MAXHOST #define NI_MAXHOST 1025 #define NI_MAXSERV 32 #endif /* * constants for inet_ntop */ #ifndef INET_ADDRSTRLEN #define INET_ADDRSTRLEN 16 #endif #ifndef INET6_ADDRSTRLEN #define INET6_ADDRSTRLEN 46 #endif /* * for shutdown(2) */ #ifndef SHUT_RD #define SHUT_RD 0 #endif #ifndef SHUT_WR #define SHUT_WR 1 #endif #ifndef SHUT_RDWR #define SHUT_RDWR 2 #endif #ifndef HAVE___ATTRIBUTE__ #define __attribute__(x) #endif ROKEN_CPP_START #ifndef IRIX4 /* fix for compiler bug */ #ifndef _WIN32 #ifdef RETSIGTYPE typedef RETSIGTYPE (*SigAction)(int); SigAction signal(int iSig, SigAction pAction); /* BSD compatible */ #endif #endif #endif #define SE_E_UNSPECIFIED (-1) #define SE_E_FORKFAILED (-2) #define SE_E_WAITPIDFAILED (-3) #define SE_E_EXECTIMEOUT (-4) #define SE_E_NOEXEC 126 #define SE_E_NOTFOUND 127 #define SE_PROCSTATUS(st) (((st) >= 0 && (st) < 126)? st: -1) #define SE_PROCSIGNAL(st) (((st) >= 128)? (st) - 128: -1) #define SE_IS_ERROR(st) ((st) < 0 || (st) >= 126) #define simple_execve rk_simple_execve ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL simple_execve(const char*, char*const[], char*const[]); #define simple_execve_timed rk_simple_execve_timed ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL simple_execve_timed(const char *, char *const[], char *const [], time_t (*)(void *), void *, time_t); #define simple_execvp rk_simple_execvp ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL simple_execvp(const char*, char *const[]); #define simple_execvp_timed rk_simple_execvp_timed ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL simple_execvp_timed(const char *, char *const[], time_t (*)(void *), void *, time_t); #define simple_execlp rk_simple_execlp ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL simple_execlp(const char*, ...); #define simple_execle rk_simple_execle ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL simple_execle(const char*, ...); #define wait_for_process rk_wait_for_process ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL wait_for_process(pid_t); #define wait_for_process_timed rk_wait_for_process_timed ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL wait_for_process_timed(pid_t, time_t (*)(void *), void *, time_t); #define pipe_execv rk_pipe_execv ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL pipe_execv(FILE**, FILE**, FILE**, const char*, ...); #define print_version rk_print_version ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL print_version(const char *); #define eread rk_eread ROKEN_LIB_FUNCTION ssize_t ROKEN_LIB_CALL eread (int fd, void *buf, size_t nbytes); #define ewrite rk_ewrite ROKEN_LIB_FUNCTION ssize_t ROKEN_LIB_CALL ewrite (int fd, const void *buf, size_t nbytes); struct hostent; #define hostent_find_fqdn rk_hostent_find_fqdn ROKEN_LIB_FUNCTION const char * ROKEN_LIB_CALL hostent_find_fqdn (const struct hostent *); #define esetenv rk_esetenv ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL esetenv(const char *, const char *, int); #define socket_set_address_and_port rk_socket_set_address_and_port ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL socket_set_address_and_port (struct sockaddr *, const void *, int); #define socket_addr_size rk_socket_addr_size ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL socket_addr_size (const struct sockaddr *); #define socket_set_any rk_socket_set_any ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL socket_set_any (struct sockaddr *, int); #define socket_sockaddr_size rk_socket_sockaddr_size ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL socket_sockaddr_size (const struct sockaddr *); #define socket_get_address rk_socket_get_address ROKEN_LIB_FUNCTION void * ROKEN_LIB_CALL socket_get_address (const struct sockaddr *); #define socket_get_port rk_socket_get_port ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL socket_get_port (const struct sockaddr *); #define socket_set_port rk_socket_set_port ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL socket_set_port (struct sockaddr *, int); #define socket_set_portrange rk_socket_set_portrange ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL socket_set_portrange (rk_socket_t, int, int); #define socket_set_debug rk_socket_set_debug ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL socket_set_debug (rk_socket_t); #define socket_set_tos rk_socket_set_tos ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL socket_set_tos (rk_socket_t, int); #define socket_set_nonblocking rk_socket_set_nonblocking ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL socket_set_nonblocking(rk_socket_t, int); #define socket_set_reuseaddr rk_socket_set_reuseaddr ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL socket_set_reuseaddr (rk_socket_t, int); #define socket_set_ipv6only rk_socket_set_ipv6only ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL socket_set_ipv6only (rk_socket_t, int); #define socket_to_fd rk_socket_to_fd ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL socket_to_fd(rk_socket_t, int); #define vstrcollect rk_vstrcollect ROKEN_LIB_FUNCTION char ** ROKEN_LIB_CALL vstrcollect(va_list *ap); #define strcollect rk_strcollect ROKEN_LIB_FUNCTION char ** ROKEN_LIB_CALL strcollect(char *first, ...); #define timevalfix rk_timevalfix ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL timevalfix(struct timeval *t1); #define timevaladd rk_timevaladd ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL timevaladd(struct timeval *t1, const struct timeval *t2); #define timevalsub rk_timevalsub ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL timevalsub(struct timeval *t1, const struct timeval *t2); #define pid_file_write rk_pid_file_write ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL pid_file_write (const char *progname); #define pid_file_delete rk_pid_file_delete ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL pid_file_delete (char **); #define read_environment rk_read_environment ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL read_environment(const char *file, char ***env); #define free_environment rk_free_environment ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL free_environment(char **); #define warnerr rk_warnerr ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL rk_warnerr(int doerrno, const char *fmt, va_list ap) __attribute__ ((__format__ (__printf__, 2, 0))); ROKEN_LIB_FUNCTION void * ROKEN_LIB_CALL rk_realloc(void *, size_t); struct rk_strpool; ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL rk_strpoolcollect(struct rk_strpool *); ROKEN_LIB_FUNCTION struct rk_strpool * ROKEN_LIB_CALL rk_strpoolprintf(struct rk_strpool *, const char *, ...) __attribute__ ((__format__ (__printf__, 2, 3))); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL rk_strpoolfree(struct rk_strpool *); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL rk_dumpdata (const char *, const void *, size_t); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL rk_undumpdata (const char *, void **, size_t *); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL rk_xfree (void *); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL rk_cloexec(int); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL rk_cloexec_file(FILE *); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL rk_cloexec_dir(DIR *); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL rk_cloexec_socket(rk_socket_t); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL ct_memcmp(const volatile void * volatile, const volatile void * volatile, size_t); void ROKEN_LIB_FUNCTION rk_random_init(void); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL rk_mkdir(const char *, mode_t); ROKEN_CPP_END #endif /* __ROKEN_COMMON_H__ */ pykrb5-0.8.0/build_helpers/heimdal/include/roken.h000066400000000000000000000161371505521762700221130ustar00rootroot00000000000000/* This is an OS dependent, generated file */ #ifndef __ROKEN_H__ #define __ROKEN_H__ /* -*- C -*- */ /* * Copyright (c) 1995-2005 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #include #include typedef int rk_socket_t; #define rk_closesocket(x) close(x) #define rk_SOCK_IOCTL(s,c,a) ioctl((s),(c),(a)) #define rk_IS_BAD_SOCKET(s) ((s) < 0) #define rk_IS_SOCKET_ERROR(rv) ((rv) < 0) #define rk_SOCK_ERRNO errno #define rk_INVALID_SOCKET (-1) #define rk_SOCK_INIT() 0 #define rk_SOCK_EXIT() do { } while(0) #define IN_LOOPBACKNET 127 #define UNREACHABLE(x) #define UNUSED_ARGUMENT(x) #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include ROKEN_CPP_START #define rk_UNCONST(x) ((void *)(uintptr_t)(const void *)(x)) #define asnprintf rk_asnprintf ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL rk_asnprintf (char **, size_t, const char *, ...) __attribute__ ((__format__ (__printf__, 3, 4))); #define vasnprintf rk_vasnprintf ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL vasnprintf (char **, size_t, const char *, va_list) __attribute__ ((__format__ (__printf__, 3, 0))); #define strlwr rk_strlwr ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL strlwr(char *); #define strsep_copy rk_strsep_copy ROKEN_LIB_FUNCTION ssize_t ROKEN_LIB_CALL strsep_copy(const char**, const char*, char*, size_t); #define strupr rk_strupr ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL strupr(char *); #define rk_strerror_r strerror_r #include ROKEN_LIB_FUNCTION struct passwd * ROKEN_LIB_CALL k_getpwnam (const char *); ROKEN_LIB_FUNCTION struct passwd * ROKEN_LIB_CALL k_getpwuid (uid_t); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL rk_getpwnam_r(const char *, struct passwd *, char *, size_t, struct passwd **); ROKEN_LIB_FUNCTION const char * ROKEN_LIB_CALL get_default_username (void); #define rk_rename(__rk_rn_from,__rk_rn_to) rename(__rk_rn_from,__rk_rn_to) #define rk_mkdir(__rk_rn_name, __rk_rn_mode) mkdir(__rk_rn_name,__rk_rn_mode) #define daemon rk_daemon ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL daemon(int, int); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL rk_pidfile (const char*); #define bswap64 rk_bswap64 ROKEN_LIB_FUNCTION uint64_t ROKEN_LIB_CALL bswap64(uint64_t); #define bswap32 rk_bswap32 ROKEN_LIB_FUNCTION unsigned int ROKEN_LIB_CALL bswap32(unsigned int); #define bswap16 rk_bswap16 ROKEN_LIB_FUNCTION unsigned short ROKEN_LIB_CALL bswap16(unsigned short); ROKEN_LIB_FUNCTION time_t ROKEN_LIB_CALL tm2time (struct tm, int); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL unix_verify_user(char *, char *); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL roken_concat (char *, size_t, ...); ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL roken_mconcat (char **, size_t, ...); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL roken_vconcat (char *, size_t, va_list); ROKEN_LIB_FUNCTION size_t ROKEN_LIB_CALL roken_vmconcat (char **, size_t, va_list); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL roken_detach_prep(int, char **, char *); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL roken_detach_finish(const char *, int); ROKEN_LIB_FUNCTION ssize_t ROKEN_LIB_CALL net_write (rk_socket_t, const void *, size_t); ROKEN_LIB_FUNCTION ssize_t ROKEN_LIB_CALL net_read (rk_socket_t, void *, size_t); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL issuid(void); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL get_window_size(int fd, int *, int *); #define copyhostent rk_copyhostent ROKEN_LIB_FUNCTION struct hostent * ROKEN_LIB_CALL copyhostent (const struct hostent *); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL getnameinfo_verified(const struct sockaddr *, socklen_t, char *, size_t, char *, size_t, int); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL roken_getaddrinfo_hostspec(const char *, int, struct addrinfo **); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL roken_getaddrinfo_hostspec2(const char *, int, int, struct addrinfo **); #define emalloc rk_emalloc ROKEN_LIB_FUNCTION void * ROKEN_LIB_CALL emalloc (size_t); #define ecalloc rk_ecalloc ROKEN_LIB_FUNCTION void * ROKEN_LIB_CALL ecalloc(size_t, size_t); #define erealloc rk_erealloc ROKEN_LIB_FUNCTION void * ROKEN_LIB_CALL erealloc (void *, size_t); #define estrdup rk_estrdup ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL estrdup (const char *); /* * kludges and such */ ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL roken_gethostby_setup(const char*, const char*); ROKEN_LIB_FUNCTION struct hostent* ROKEN_LIB_CALL roken_gethostbyname(const char*); ROKEN_LIB_FUNCTION struct hostent* ROKEN_LIB_CALL roken_gethostbyaddr(const void*, size_t, int); #define roken_getservbyname(x,y) getservbyname(x,y) #define roken_openlog(a,b,c) openlog(a,b,c) #define roken_getsockname(a,b,c) getsockname(a,b,c) ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL mini_inetd_addrinfo (struct addrinfo*, rk_socket_t *); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL mini_inetd (int, rk_socket_t *); #define closefrom rk_closefrom ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL closefrom(int); # define rk_random() arc4random() /* Microsoft VC 2010 POSIX definitions */ ROKEN_CPP_END #endif /* __ROKEN_H__ */ pykrb5-0.8.0/build_helpers/heimdal/include/rtbl.h000066400000000000000000000073361505521762700217410ustar00rootroot00000000000000/* * Copyright (c) 2000,2004 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef __rtbl_h__ #define __rtbl_h__ #ifndef ROKEN_LIB_FUNCTION #ifdef _WIN32 #define ROKEN_LIB_FUNCTION #define ROKEN_LIB_CALL __cdecl #else #define ROKEN_LIB_FUNCTION #define ROKEN_LIB_CALL #endif #endif #if !defined(__GNUC__) && !defined(__attribute__) #define __attribute__(x) #endif #ifdef __cplusplus extern "C" { #endif struct rtbl_data; typedef struct rtbl_data *rtbl_t; #define RTBL_ALIGN_LEFT 0 #define RTBL_ALIGN_RIGHT 1 /* flags */ #define RTBL_HEADER_STYLE_NONE 1 #define RTBL_JSON 2 ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL rtbl_add_column (rtbl_t, const char*, unsigned int); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL rtbl_add_column_by_id (rtbl_t, unsigned int, const char*, unsigned int); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL rtbl_add_column_entryv_by_id (rtbl_t table, unsigned int id, const char *fmt, ...) __attribute__ ((__format__ (__printf__, 3, 0))); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL rtbl_add_column_entry (rtbl_t, const char*, const char*); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL rtbl_add_column_entryv (rtbl_t, const char*, const char*, ...) __attribute__ ((__format__ (__printf__, 3, 0))); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL rtbl_add_column_entry_by_id (rtbl_t, unsigned int, const char*); ROKEN_LIB_FUNCTION rtbl_t ROKEN_LIB_CALL rtbl_create (void); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL rtbl_destroy (rtbl_t); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL rtbl_format (rtbl_t, FILE*); ROKEN_LIB_FUNCTION char * ROKEN_LIB_CALL rtbl_format_str (rtbl_t); ROKEN_LIB_FUNCTION unsigned int ROKEN_LIB_CALL rtbl_get_flags (rtbl_t); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL rtbl_new_row (rtbl_t); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL rtbl_set_column_affix_by_id (rtbl_t, unsigned int, const char*, const char*); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL rtbl_set_column_prefix (rtbl_t, const char*, const char*); ROKEN_LIB_FUNCTION void ROKEN_LIB_CALL rtbl_set_flags (rtbl_t, unsigned int); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL rtbl_set_prefix (rtbl_t, const char*); ROKEN_LIB_FUNCTION int ROKEN_LIB_CALL rtbl_set_separator (rtbl_t, const char*); #ifdef __cplusplus } #endif #endif /* __rtbl_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/sl.h000066400000000000000000000046171505521762700214130ustar00rootroot00000000000000/* * Copyright (c) 1995 - 2004 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef _SL_H #define _SL_H #define SL_BADCOMMAND -1 typedef int (*cmd_func)(int, char **); struct sl_cmd { const char *name; cmd_func func; const char *usage; const char *help; }; typedef struct sl_cmd SL_cmd; #ifdef __cplusplus extern "C" { #endif void sl_help (SL_cmd *, int argc, char **argv); int sl_loop (SL_cmd *, const char *prompt); int sl_command_loop (SL_cmd *cmds, const char *prompt, void **data); int sl_command (SL_cmd *cmds, int argc, char **argv); int sl_make_argv(char*, int*, char***); void sl_apropos (SL_cmd *cmd, const char *topic); SL_cmd *sl_match (SL_cmd *cmds, char *cmd, int exactp); void sl_slc_help (SL_cmd *cmds, int argc, char **argv); void sl_did_you_mean(SL_cmd *cmds, const char *match); #ifdef __cplusplus } #endif #endif /* _SL_H */ pykrb5-0.8.0/build_helpers/heimdal/include/wind.h000066400000000000000000000061371505521762700217350ustar00rootroot00000000000000/* * Copyright (c) 2004 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ #ifndef _WIND_H_ #define _WIND_H_ #include #include #include typedef unsigned int wind_profile_flags; #define WIND_PROFILE_NAME 0x00000001 #define WIND_PROFILE_SASL 0x00000002 #define WIND_PROFILE_LDAP 0x00000004 #define WIND_PROFILE_LDAP_CASE 0x00000008 #define WIND_PROFILE_LDAP_CASE_EXACT_ATTRIBUTE 0x00010000 #define WIND_PROFILE_LDAP_CASE_EXACT_ASSERTION 0x00020000 #define WIND_PROFILE_LDAP_NUMERIC 0x00040000 #define WIND_PROFILE_LDAP_TELEPHONE 0x00080000 /* flags to wind_ucs2read/wind_ucs2write */ #define WIND_RW_LE 1 #define WIND_RW_BE 2 #define WIND_RW_BOM 4 int wind_stringprep(const uint32_t *, size_t, uint32_t *, size_t *, wind_profile_flags); int wind_profile(const char *, wind_profile_flags *); int wind_punycode_label_toascii(const uint32_t *, size_t, char *, size_t *); int wind_utf8ucs4(const char *, uint32_t *, size_t *); int wind_utf8ucs4_length(const char *, size_t *); int wind_ucs4utf8(const uint32_t *, size_t, char *, size_t *); int wind_ucs4utf8_length(const uint32_t *, size_t, size_t *); int wind_utf8ucs2(const char *, uint16_t *, size_t *); int wind_utf8ucs2_length(const char *, size_t *); int wind_ucs2utf8(const uint16_t *, size_t, char *, size_t *); int wind_ucs2utf8_length(const uint16_t *, size_t, size_t *); int wind_ucs2read(const void *, size_t, unsigned int *, uint16_t *, size_t *); int wind_ucs2write(const uint16_t *, size_t, unsigned int *, void *, size_t *); #endif /* _WIND_H_ */ pykrb5-0.8.0/build_helpers/heimdal/include/wind_err.h000066400000000000000000000014731505521762700226030ustar00rootroot00000000000000/* Generated from wind_err.et */ /* $Id$ */ #ifndef __wind_err_h__ #define __wind_err_h__ struct et_list; void initialize_wind_error_table_r(struct et_list **); void initialize_wind_error_table(void); #define init_wind_err_tbl initialize_wind_error_table typedef enum wind_error_number{ WIND_ERR_NONE = -969269760, WIND_ERR_NO_PROFILE = -969269759, WIND_ERR_OVERRUN = -969269758, WIND_ERR_UNDERUN = -969269757, WIND_ERR_LENGTH_NOT_MOD2 = -969269756, WIND_ERR_LENGTH_NOT_MOD4 = -969269755, WIND_ERR_INVALID_UTF8 = -969269754, WIND_ERR_INVALID_UTF16 = -969269753, WIND_ERR_INVALID_UTF32 = -969269752, WIND_ERR_NO_BOM = -969269751, WIND_ERR_NOT_UTF16 = -969269750 } wind_error_number; #define ERROR_TABLE_BASE_wind -969269760 #define COM_ERR_BINDDOMAIN_wind "heim_com_err-969269760" #endif /* __wind_err_h__ */ pykrb5-0.8.0/build_helpers/heimdal/include/xdbm.h000066400000000000000000000036451505521762700217270ustar00rootroot00000000000000/* * Copyright (c) 1995 - 2002 Kungliga Tekniska Högskolan * (Royal Institute of Technology, Stockholm, Sweden). * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * 3. Neither the name of the Institute nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* $Id$ */ /* Generic *dbm include file */ #ifndef __XDBM_H__ #define __XDBM_H__ #if HAVE_DB_NDBM #define DB_DBM_HSEARCH 1 #include #elif HAVE_NDBM #if defined(HAVE_GDBM_NDBM_H) #include #elif defined(HAVE_NDBM_H) #include #endif #endif /* HAVE_NDBM */ #endif /* __XDBM_H__ */ pykrb5-0.8.0/build_helpers/lib.sh000077500000000000000000000043501505521762700166750ustar00rootroot00000000000000#!/bin/bash lib::setup::debian_requirements() { echo "Installing Debian based pre-requisites" export DEBIAN_FRONTEND=noninteractive apt-get update if [ x"$KRB5_PROVIDER" = "xheimdal" ]; then echo "Installing Heimdal packages for Debian" apt-get -y install \ heimdal-{clients,dev,kdc} export PATH="/usr/lib/heimdal-servers:${PATH}" else echo "Installing MIT Kerberos packages for Debian" apt-get -y install \ krb5-{user,kdc,admin-server,multidev} \ libkrb5-dev fi } lib::setup::system_requirements() { if [ x"${GITHUB_ACTIONS}" = "xtrue" ]; then echo "::group::Installing System Requirements" fi if [ -f /etc/debian_version ]; then lib::setup::debian_requirements elif [ "$(uname)" == "Darwin" ]; then echo "No system requirements required for macOS" else echo "Distro not found!" false fi if [ x"${GITHUB_ACTIONS}" = "xtrue" ]; then echo "::endgroup::" fi } lib::setup::python_requirements() { if [ x"${GITHUB_ACTIONS}" = "xtrue" ]; then echo "::group::Installing Python Requirements" fi echo "Installing krb5" # Getting the version is important so that pip prioritises our local dist python -m pip install build KRB5_VERSION="$( python -c "import build.util; print(build.util.project_wheel_metadata('.').get('Version'))" )" python -m pip install krb5=="${KRB5_VERSION}" \ --find-links dist \ --verbose echo "Installing dev dependencies" python -m pip install -r requirements-dev.txt if [ x"${GITHUB_ACTIONS}" = "xtrue" ]; then echo "::endgroup::" fi } lib::sanity::run() { if [ x"${GITHUB_ACTIONS}" = "xtrue" ]; then echo "::group::Running Sanity Checks" fi python -m black . --check python -m isort . --check-only python -m mypy . if [ x"${GITHUB_ACTIONS}" = "xtrue" ]; then echo "::endgroup::" fi } lib::tests::run() { if [ x"${GITHUB_ACTIONS}" = "xtrue" ]; then echo "::group::Running Tests" fi python -m pytest -v --junitxml junit/test-results.xml if [ x"${GITHUB_ACTIONS}" = "xtrue" ]; then echo "::endgroup::" fi } pykrb5-0.8.0/build_helpers/run-ci.sh000077500000000000000000000003751505521762700173270ustar00rootroot00000000000000#!/bin/bash -ex # Set by GHA setup-python if [[ -n "${pythonLocation}" ]]; then PATH="${pythonLocation}/bin:${PATH}" fi source ./build_helpers/lib.sh lib::setup::system_requirements lib::setup::python_requirements lib::sanity::run lib::tests::run pykrb5-0.8.0/build_helpers/run-container.sh000077500000000000000000000024571505521762700207210ustar00rootroot00000000000000#!/bin/bash -ex # KRB5_PROVIDER and DEBIAN_VERSION can be set to run tests against different # versions. A full test suite before release should be run with # DEBIAN_VERSION=10 KRB5_PROVIDER=mit build_helpers/run-container.sh # DEBIAN_VERSION=10 KRB5_PROVIDER=heimdal build_helpers/run-container.sh # DEBIAN_VERSION=11 KRB5_PROVIDER=mit build_helpers/run-container.sh # DEBIAN_VERSION=12 KRB5_PROVIDER=mit build_helpers/run-container.sh export DEBIAN_VERSION="${DEBIAN_VERSION:-10}" docker run \ --rm \ --interactive \ --hostname test.krbtest.com \ --volume "$( pwd )":/tmp/build:z \ --workdir /tmp/build \ --env KRB5_PROVIDER=${KRB5_PROVIDER:-mit} \ --env DEBIAN_VERSION=${DEBIAN_VERSION} \ debian:${DEBIAN_VERSION} /bin/bash -ex -c 'source /dev/stdin' << 'EOF' source ./build_helpers/lib.sh lib::setup::system_requirements apt-get -y install \ python3 \ python3-{dev,pip,venv} . /etc/os-release if [ "$VERSION_ID" = "10" ]; then ln -s /usr/bin/python3 /usr/bin/python else python3 -m venv .venv source .venv/bin/activate fi python -m pip install build python -m build lib::setup::python_requirements # Ensure we don't pollute the local dir + mypy doesn't like this rm -rf dist rm -rf build lib::sanity::run export PYTEST_ADDOPTS="--color=yes" lib::tests::run EOF pykrb5-0.8.0/pyproject.toml000066400000000000000000000023051505521762700156610ustar00rootroot00000000000000[build-system] requires = [ "Cython == 3.1.3", "setuptools >= 42.0.0", # Supports license_files ] build-backend = "setuptools.build_meta" # FUTURE: Mandate newer setuptools to use pyproject.toml configuration # Currently it fails when using older pip versions that are still used by some # Linux distributions with: # WARNING: Generating metadata for package krb5 produced metadata for project name unknown. Fix your #egg=krb5 fragments. [tool.black] line-length = 120 include = '\.pyi?$' exclude = ''' /( \.git | \.hg | \.mypy_cache | \.tox | \.venv | _build | buck-out | build | dist )/ ''' [tool.isort] profile = "black" [tool.mypy] # mypy doesn't seem to like pyenv and extra typeshed libraries exclude = "setup.py" mypy_path = "$MYPY_CONFIG_FILE_DIR/src:$MYPY_CONFIG_FILE_DIR/stubs" show_error_codes = true show_column_numbers = true disallow_any_unimported = true disallow_untyped_calls = true disallow_untyped_defs = true disallow_incomplete_defs = true check_untyped_defs = true disallow_untyped_decorators = true no_implicit_reexport = true warn_redundant_casts = true warn_unused_ignores = true [tool.pytest.ini_options] testpaths = "tests" addopts = "--import-mode=importlib" pykrb5-0.8.0/requirements-dev.txt000066400000000000000000000001761505521762700170110ustar00rootroot00000000000000black==25.1.0 isort==6.0.1 k5test>=0.10.4 # Needed for MITRealm.start_kadmind env default mypy==1.17.1 pre-commit pytest tox pykrb5-0.8.0/setup.cfg000066400000000000000000000016621505521762700145730ustar00rootroot00000000000000[metadata] name = krb5 version = 0.8.0 url = https://github.com/jborean93/pykrb5 author = Jordan Borean author_email = jborean93@gmail.com license = MIT license_files = LICENSE description = Kerberos API bindings for Python long_description = file: README.md long_description_content_type = text/markdown keywords = krb5 kerberos classifiers = Development Status :: 4 - Beta Programming Language :: Python :: 3 Programming Language :: Python :: 3.9 Programming Language :: Python :: 3.10 Programming Language :: Python :: 3.11 Programming Language :: Python :: 3.12 Programming Language :: Python :: 3.13 Programming Language :: Python :: 3.14 [options] package_dir = =src packages = find: include_package_data = True python_requires = >= 3.9 [options.packages.find] where = src [options.package_data] krb5 = py.typed *.pyi [options.exclude_package_data] krb5 = *.pxd *.pyx *.h pykrb5-0.8.0/setup.py000077500000000000000000000213771505521762700144740ustar00rootroot00000000000000#!/usr/bin/env python # Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) """Builds the project. Logic has mostly been derived from python-gssapi - thanks to them for all the hard work. https://github.com/pythongssapi/python-gssapi/blob/main/setup.py """ import ctypes import ctypes.util import os import os.path import platform import shlex import subprocess import sys import typing from Cython.Build import cythonize from setuptools import Extension, setup SKIP_EXTENSIONS = os.environ.get("KRB5_SKIP_EXTENSIONS", "false").lower() == "true" SKIP_MODULE_CHECK = os.environ.get("KRB5_SKIP_MODULE_CHECK", "false").lower() == "true" CYTHON_LINETRACE = os.environ.get("KRB5_CYTHON_TRACING", "false").lower() == "true" def run_command(*args: str) -> str: stdout = subprocess.check_output(args, shell=True) return stdout.decode("utf-8").strip() def make_extension( name: str, module: ctypes.CDLL, canary: typing.Optional[str] = None, **kwargs: typing.Any, ) -> Extension: source = os.path.join("src", name.replace(".", os.sep)) + ".pyx" if not SKIP_MODULE_CHECK and canary and not hasattr(module, canary): print(f"Skipping {source} as it is not supported by the selected Kerberos implementation.") return if not os.path.exists(source): raise FileNotFoundError(source) print(f"Compiling {source}") return Extension( name=name, sources=[source], **kwargs, ) def get_krb5_config() -> str: """Gets the path to the krb5-config binary. Determines the path to the krb5-confing to use for detecting linker and compiler args on the current platform. The default behaviour is to use the value of the env var ``KRB5_KRB5CONFIG`` defaulting to just krb5-conf in the path. FreeBSD is slightly different as it favours ``/usr/local/bin/krb5-config`` over ``/usr/bin/krb5-config`` due to the latter being based on an ancient Heimdal version. Returns: str: Path to krb5-conf. """ kc_env = os.environ.get("KRB5_KRB5CONFIG", "") kc = kc_env if kc_env else "krb5-config" if sys.platform.startswith("freebsd") and not kc_env: # FreeBSD does $PATH backward, for our purposes. That is, the package # manager's version of the software is in /usr/local, which is in PATH # *after* the version in /usr. We prefer the package manager's version # because the Heimdal in base is truly ancient, but this can be overridden # - either in the "normal" fashion by putting something in PATH in front # of it, or by removing /usr/local from PATH. bins = [] for entry in os.environ.get("PATH", "").split(os.pathsep): p = os.path.join(entry, "krb5-config") if not os.path.exists(p): continue bins.append(p) if len(bins) > 1 and bins[0] == "/usr/bin/krb5-config" and "/usr/local/bin/krb5-config" in bins: kc = "/usr/local/bin/krb5-config" return kc def get_krb5_lib_path( libraries: typing.List[str], library_dirs: typing.List[str], link_args: typing.List[str], macos_native: bool, ) -> str: """Gets the path to the main libkrb5.so library. This path is used to check if the Kerberos library supports the optional APIs when compiling. Args: libraries: The libraries specified by krb5-config (-l). librariy_dirs: The library dirs specified by krb5-config (-L). link_args: The linking args specified by krb5-config. macos_native: Whether this is for the native macOS Kerberos library. Returns: str: The path to the krb5 library. """ krb5_lib = os.environ.get("KRB5_MAIN_LIB", "") krb5_path = "" if not krb5_lib and macos_native: # Cannot use find_library as it won't look into the private framework path. krb5_lib = "/System/Library/PrivateFrameworks/Heimdal.framework/Heimdal" elif not krb5_lib: for opt in libraries: if opt.startswith("krb5"): ext = { "nt": "dll", "darwin": "dylib", }.get(os.name, "so") krb5_lib = f"lib{opt}.{ext}" break for opt in link_args: # To support Heimdal on Debian, read the linker path. if opt.startswith("-Wl,/"): krb5_path = opt[4:] + "/" break if not krb5_path: for d in library_dirs: if os.path.exists(os.path.join(d, krb5_lib)): krb5_path = d break if not krb5_lib: raise Exception( "Could not find the main krb5 shared library. Set this manually with the env var KRB5_MAIN_LIB." ) return os.path.join(krb5_path, krb5_lib) raw_extensions = [] if not SKIP_EXTENSIONS: kc = get_krb5_config() print(f"Using krb5-config at '{kc}'") macos_native = False if sys.platform == "darwin": mac_ver = [int(v) for v in platform.mac_ver()[0].split(".")] macos_native = mac_ver >= [10, 7, 0] compile_args, raw_link_args = [ shlex.split(os.environ[e], posix=True) if e in os.environ else None for e in ["KRB5_COMPILER_ARGS", "KRB5_LINKER_ARGS"] ] if compile_args is None: if macos_native: compile_args = [] else: compile_args = shlex.split(run_command(f"{kc} --cflags krb5")) if CYTHON_LINETRACE: compile_args.append("-DCYTHON_TRACE_NOGIL=1") if raw_link_args is None: if macos_native: raw_link_args = ["-framework", "Heimdal", "-F", "/System/Library/PrivateFrameworks"] else: raw_link_args = shlex.split(run_command(f"{kc} --libs krb5")) library_dirs, include_dirs, libraries, link_args = [], [], [], [] for arg in raw_link_args: if arg.startswith("-L"): library_dirs.append(arg[2:]) elif arg.startswith("-l"): libraries.append(arg[2:]) elif arg.startswith("-I"): include_dirs.append(arg[2:]) else: link_args.append(arg) if macos_native: # Because this is doing a naughty thing and linking against a private framework there are no krb5.h header files # available. A hack is to just compile Heimdal itself and include that during compilation. heimdal_dir = os.environ.get("KRB5_MACOS_HEIMDAL_DIR", "") if not heimdal_dir: heimdal_dir = os.path.join(os.path.dirname(__file__), "build_helpers", "heimdal") include_dirs.append(os.path.join(os.path.abspath(heimdal_dir), "include")) krb5_path = get_krb5_lib_path(libraries, library_dirs, link_args, macos_native) print(f"Using {krb5_path} as Kerberos module for platform checks") krb5 = ctypes.CDLL(krb5_path) if hasattr(krb5, "krb5_xfree"): compile_args.append("-DHEIMDAL_XFREE") for e in [ "ccache", ("ccache_mit", "krb5_cc_dup"), ("ccache_match", "krb5_cc_cache_match"), ("ccache_support_switch", "krb5_cc_support_switch"), "cccol", ("chpw_message_mit", "krb5_chpw_message"), "context", ("context_mit", "krb5_init_secure_context"), "creds", ("creds_marshal_mit", "krb5_marshal_credentials"), ("creds_mit", "krb5_get_etype_info"), "creds_opt", ("creds_opt_heimdal", "krb5_get_init_creds_opt_set_default_flags"), ("creds_opt_mit", "krb5_get_init_creds_opt_set_out_ccache"), ("creds_opt_set_in_ccache", "krb5_get_init_creds_opt_set_in_ccache"), ("creds_opt_set_pac_request", "krb5_get_init_creds_opt_set_pac_request"), "exceptions", "keyblock", ("keyblock_mit", "krb5_c_string_to_key_with_params"), "kt", ("kt_mit", "krb5_kt_dup"), ("kt_heimdal", "krb5_kt_get_full_name"), ("kt_have_content", "krb5_kt_have_content"), "principal", ("principal_heimdal", "krb5_principal_get_realm"), "set_password", "string", ("string_mit", "krb5_enctype_to_name"), ]: name = e canary = None if isinstance(e, tuple): name = e[0] if len(e) > 1: canary = e[1] ext = make_extension( f"krb5._{name}", module=krb5, canary=canary, extra_link_args=link_args, extra_compile_args=compile_args, include_dirs=include_dirs, library_dirs=library_dirs, libraries=libraries, ) if ext: raw_extensions.append(ext) setup( ext_modules=cythonize( raw_extensions, language_level=3, compiler_directives={"linetrace": CYTHON_LINETRACE}, ), ) pykrb5-0.8.0/src/000077500000000000000000000000001505521762700135345ustar00rootroot00000000000000pykrb5-0.8.0/src/krb5/000077500000000000000000000000001505521762700143775ustar00rootroot00000000000000pykrb5-0.8.0/src/krb5/__init__.py000066400000000000000000000166511505521762700165210ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._adpi import ADPolicyInfo, ADPolicyInfoProp from krb5._ccache import ( CCache, CredentialsRetrieveFlags, cc_default, cc_default_name, cc_destroy, cc_get_config, cc_get_name, cc_get_principal, cc_get_type, cc_initialize, cc_new_unique, cc_remove_cred, cc_resolve, cc_retrieve_cred, cc_set_config, cc_set_default_name, cc_store_cred, cc_switch, ) from krb5._cccol import cccol_iter from krb5._context import ( Context, get_default_realm, init_context, set_default_realm, set_real_time, timeofday, us_timeofday, ) from krb5._creds import ( Creds, InitCredsContext, Krb5Prompt, TicketFlags, TicketTimes, get_init_creds_keytab, get_init_creds_password, get_renewed_creds, init_creds_get, init_creds_get_creds, init_creds_init, init_creds_set_keytab, init_creds_set_password, ) from krb5._creds_opt import ( GetInitCredsOpt, get_init_creds_opt_alloc, get_init_creds_opt_set_anonymous, get_init_creds_opt_set_canonicalize, get_init_creds_opt_set_etype_list, get_init_creds_opt_set_forwardable, get_init_creds_opt_set_proxiable, get_init_creds_opt_set_renew_life, get_init_creds_opt_set_salt, get_init_creds_opt_set_tkt_life, ) from krb5._exceptions import Krb5Error from krb5._keyblock import KeyBlock, copy_keyblock, init_keyblock from krb5._kt import ( KeyTab, KeyTabEntry, kt_add_entry, kt_default, kt_default_name, kt_get_entry, kt_get_name, kt_get_type, kt_read_service_key, kt_remove_entry, kt_resolve, ) from krb5._principal import ( NameType, Principal, PrincipalParseFlags, PrincipalUnparseFlags, build_principal, copy_principal, parse_name_flags, unparse_name_flags, ) from krb5._set_password import ( SetPasswordResult, SetPasswordResultCode, set_password, set_password_using_ccache, ) from krb5._string import enctype_to_string, string_to_enctype __all__ = [ "ADPolicyInfo", "ADPolicyInfoProp", "CCache", "Context", "CredentialsRetrieveFlags", "Creds", "GetInitCredsOpt", "InitCredsContext", "KeyBlock", "KeyTab", "KeyTabEntry", "Krb5Error", "Krb5Prompt", "NameType", "Principal", "PrincipalParseFlags", "PrincipalUnparseFlags", "SetPasswordResult", "SetPasswordResultCode", "TicketFlags", "TicketTimes", "build_principal", "cc_default", "cc_default_name", "cc_destroy", "cc_get_config", "cc_get_name", "cc_get_principal", "cc_get_type", "cc_initialize", "cc_new_unique", "cc_remove_cred", "cc_resolve", "cc_retrieve_cred", "cc_set_config", "cc_set_default_name", "cc_store_cred", "cc_switch", "cccol_iter", "copy_keyblock", "copy_principal", "enctype_to_string", "get_default_realm", "get_init_creds_keytab", "get_init_creds_opt_alloc", "get_init_creds_opt_set_anonymous", "get_init_creds_opt_set_canonicalize", "get_init_creds_opt_set_etype_list", "get_init_creds_opt_set_forwardable", "get_init_creds_opt_set_proxiable", "get_init_creds_opt_set_renew_life", "get_init_creds_opt_set_salt", "get_init_creds_opt_set_tkt_life", "get_init_creds_password", "get_renewed_creds", "init_context", "init_creds_get", "init_creds_get_creds", "init_creds_init", "init_creds_set_keytab", "init_creds_set_password", "init_keyblock", "kt_add_entry", "kt_default", "kt_default_name", "kt_get_entry", "kt_get_name", "kt_get_type", "kt_read_service_key", "kt_remove_entry", "kt_resolve", "parse_name_flags", "set_default_realm", "set_password", "set_password_using_ccache", "set_real_time", "string_to_enctype", "timeofday", "unparse_name_flags", "us_timeofday", ] # Provider or version specific APIs try: from krb5._ccache_mit import cc_dup except ImportError: pass else: __all__.append("cc_dup") try: from krb5._creds_mit import get_etype_info, get_validated_creds except ImportError: pass else: __all__.append("get_etype_info") __all__.append("get_validated_creds") try: from krb5._creds_marshal_mit import marshal_credentials, unmarshal_credentials except ImportError: pass else: __all__.append("marshal_credentials") __all__.append("unmarshal_credentials") try: from krb5._chpw_message_mit import chpw_message except ImportError: pass else: __all__.append("chpw_message") try: from krb5._ccache_match import cc_cache_match except ImportError: pass else: __all__.append("cc_cache_match") try: from krb5._ccache_support_switch import cc_support_switch except ImportError: pass else: __all__.append("cc_support_switch") try: from krb5._context_mit import init_secure_context except ImportError: pass else: __all__.append("init_secure_context") try: from krb5._context_mit import get_time_offsets except ImportError: pass else: __all__.append("get_time_offsets") try: from krb5._creds_opt_heimdal import get_init_creds_opt_set_default_flags except ImportError: pass else: __all__.append("get_init_creds_opt_set_default_flags") try: from krb5._creds_opt_mit import ( FastFlags, get_init_creds_opt_set_fast_ccache, get_init_creds_opt_set_fast_ccache_name, get_init_creds_opt_set_fast_flags, get_init_creds_opt_set_out_ccache, get_init_creds_opt_set_pa, ) except ImportError: pass else: __all__.extend( [ "FastFlags", "get_init_creds_opt_set_fast_ccache", "get_init_creds_opt_set_fast_ccache_name", "get_init_creds_opt_set_fast_flags", "get_init_creds_opt_set_out_ccache", "get_init_creds_opt_set_pa", ] ) try: from krb5._creds_opt_set_in_ccache import get_init_creds_opt_set_in_ccache except ImportError: pass else: __all__.append("get_init_creds_opt_set_in_ccache") try: from krb5._creds_opt_set_pac_request import get_init_creds_opt_set_pac_request except ImportError: pass else: __all__.append("get_init_creds_opt_set_pac_request") try: from krb5._keyblock_mit import c_string_to_key except ImportError: pass else: __all__.append("c_string_to_key") try: from krb5._kt_mit import kt_client_default, kt_dup except ImportError: pass else: def kt_get_full_name( context: Context, keytab: KeyTab, ) -> bytes: # This isn't implemented in MIT so mock the same behaviour return (keytab.kt_type or b"") + b":" + (keytab.name or b"") __all__.extend(["kt_client_default", "kt_dup", "kt_get_full_name", "kt_get_type"]) try: from krb5._kt_heimdal import kt_get_full_name except ImportError: pass else: __all__.extend(["kt_get_full_name", "kt_get_type"]) try: from krb5._kt_have_content import kt_have_content except ImportError: pass else: __all__.append("kt_have_content") try: from krb5._principal_heimdal import principal_get_realm except ImportError: pass else: __all__.extend(["principal_get_realm"]) try: from krb5._string_mit import enctype_to_name except ImportError: pass else: __all__.append("enctype_to_name") pykrb5-0.8.0/src/krb5/_adpi.py000066400000000000000000000050671505521762700160350ustar00rootroot00000000000000# Copyright: (c) 2024 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from __future__ import annotations import enum import struct import typing FORMAT = "!HIIIQQ" class ADPolicyInfoProp(enum.IntFlag): COMPLEX = 0x00000001 NO_ANON_CHANGEv = 0x00000002 NO_CLEAR_CHANGE = 0x00000004 LOCKOUT_ADMINS = 0x00000008 STORE_CLEARTEXT = 0x00000010 REFUSE_CHANGE = 0x00000020 class ADPolicyInfo(typing.NamedTuple): """The structure containing the reasons for failed password change attempt. Should be used to inform the end user how to meet the policy requirements. This is specific to Active Directory and is returned as the `server_response` by :meth:`set_password()` and :meth:`set_password_using_ccache()`. When using MIT library, this structure may be encoded back to bytes and passed to :meth:`chpw_message()` to obtain a human readable response. With Heimdal, it is required to provide a custom implementation based on the known fields below. The structure contains the following fields:\n - `properties` - Password policy bit flags (see below) - `min_length` - Minimal password length - `history` - Number of passwords that this system remembers - `max_age` - Maximum password age in 100 nanosecond units - `min_age` - Minimum password age in 100 nanosecond units The only known property flag is `COMPLEX` which means that the password must meet certain character variety and not contain the user's name. To convert `max_age` and `min_age` to seconds, divide them by 10,000,000. """ properties: ADPolicyInfoProp min_length: int history: int max_age: int min_age: int @classmethod def from_bytes(cls, data: bytes) -> ADPolicyInfo: """Decode AD policy result from byte string Args: data: Serialized AD policy `server_response` Returns: ADPolicyInfo: Decoded AD policy result strcture Raises: ValueError: Invalid data length or wrong signature """ if len(data) != struct.calcsize(FORMAT): raise ValueError("Invalid data length") signature, min_length, history, flags, max_age, min_age = struct.unpack(FORMAT, data) if signature != 0x0000: raise ValueError("Invalid signature") return cls( min_length=min_length, history=history, max_age=max_age, min_age=min_age, properties=ADPolicyInfoProp(flags), ) pykrb5-0.8.0/src/krb5/_ccache.pxd000066400000000000000000000004211505521762700164560ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._context cimport Context from krb5._krb5_types cimport * cdef class CCache: cdef Context ctx cdef krb5_ccache raw pykrb5-0.8.0/src/krb5/_ccache.pyi000066400000000000000000000206361505521762700164760ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import enum import typing from krb5._context import Context from krb5._creds import Creds from krb5._principal import Principal class CredentialsRetrieveFlags(enum.IntEnum): """Flags used to control :meth:`cc_retrieve_cred` and :meth:`cc_remove_cred`.""" none = ... #: No matching flags set match_times = ... #: The requested lifetime must be at least as great as specified match_is_skey = ... #: The is_skey field must match exactly match_flags = ... #: All the flags set in the match credentials must be set match_times_exact = ... #: All the time fields must match exactly match_flags_exact = ... #: All the flags must match exactly match_authdata = ... #: The authorization data must match match_srv_nameonly = ... #: Only the name portion of the principal name must match match_2nd_tkt = ... #: The second ticket must match match_keytype = ... #: The encryption key type must match supported_ktypes = ... #: The supported key types must match class CCache: """Kerberos CCache This class represents a Credential Cache object. Args: context: Krb5 context. """ def __iter__(self) -> typing.Iterator[Creds]: """Iterate credentials in a ccache.""" @property def addr(self) -> typing.Optional[int]: """The raw krb5_ccache pointer address of this credential cache.""" @property def name(self) -> typing.Optional[bytes]: """The name/residual of the credential cache.""" @property def principal(self) -> typing.Optional[Principal]: """Default client principal of the credential cache.""" @property def cache_type(self) -> typing.Optional[bytes]: """The type of the credential cache.""" def cc_default( context: Context, ) -> CCache: """Resolve the default credential cache name. Create a handle to the default credential cache as given by :meth:`cc_default_name()`. Args: context: Krb5 context. Returns: CCache: The opened credential cache. """ def cc_default_name( context: Context, ) -> bytes: """Get the name of the default credential cache. The name of the default credential cache. This value consults a wide range of sources such as the ``KRB5CCNAME`` env var, config settings, build time variables, etc. Args: context: Krb5 context. Returns: bytes: The name of the default credential cache. """ def cc_destroy( context: Context, cache: CCache, ) -> None: """Destroy a credential cache. Destroys the contents of the cache and closes the handle to it. Args: context: Krb5 context. cache: The credential cache to destroy. """ def cc_get_name( context: Context, cache: CCache, ) -> bytes: """Retrieve the name of a credential cache. Gets the name of the credential, but not the type of a credential cache. Args: context: Krb5 context. cache: The credential cache to query. Returns: bytes: The credential cache name. """ def cc_get_principal( context: Context, cache: CCache, ) -> Principal: """Get the default principal of a credential cache. Gets the default principal of a credential as set by :meth:`cc_initialize()`. Args: context: Krb5 context. cache: The credential cache to query. Returns: Principal: The default principal of the cache. """ def cc_get_type( context: Context, cache: CCache, ) -> bytes: """Retrieve the type of a credential cache. Gets the credential cache type. Args: context: Krb5 context. cache: The credential cache to query. Returns: bytes: The credential cache type. """ def cc_initialize( context: Context, cache: CCache, principal: Principal, ) -> None: """Initialize a credential cache. Destroy any existing contents of a cache and initialize it for the default principal specified. Args: context: Krb5 context. cache: The cache to destroy and recreate. principal: The default principal of the cache. """ def cc_new_unique( context: Context, cred_type: bytes, hint: typing.Optional[bytes] = None, ) -> CCache: """Create a new unique credential cache. Create a new credential cache of the specified type with a unique name. Args: context: Krb5 context. cred_type: The credential cache type to create. hint: Unused. Returns: CCache: The created credential cache. """ def cc_remove_cred( context: Context, cache: CCache, flags: typing.Union[int, CredentialsRetrieveFlags], creds: Creds, ) -> None: """Remove matching credentials from a credential cache. Remove all credential which match creds according to flags from the credential cache. Args: context: Krb5 context. cache: The credential cache to store the creds into. flags: The flags describing how to perform the matching. creds: The credentials to match against. """ def cc_resolve( context: Context, name: bytes, ) -> CCache: """Resolve a credential cache name. Resolves/opens a credential cache by the name specified. The name should be in the form ``type:residual`` where the type is known to the krb5 library being called. If the name does not contain a colon then it is interpreted as a file name (``FILE:*``). Args: context: Krb5 context. name: The name of the cache to resolve. Returns: CCache: The credential cache that was resolved. """ def cc_retrieve_cred( context: Context, cache: CCache, flags: typing.Union[int, CredentialsRetrieveFlags], mcreds: Creds, ) -> Creds: """Retrieve matching credentials from a credential cache. Retrieve all credential which match creds according to flags from the credential cache. Args: context: Krb5 context. cache: The credential cache to store the creds into. flags: The flags describing how to perform the matching. mcreds: The credentials to match against. Returns: Creds: The matching credentials. """ def cc_set_default_name( context: Context, name: typing.Optional[bytes], ) -> None: """Set the default ccache name. Set the default credential cache name to the name specified for future operations using the context. If name is `None` or an empty byte string this will clear any previous application-set default name and forget any cached value of the default name for the context. Args: context: Krb5 context. name: The default credential name or `None` to reset back to the config defaults. """ def cc_store_cred( context: Context, cache: CCache, creds: Creds, ) -> None: """Store credentials in a credential cache. Stores the credentials into the credential cache specified. Args: context: Krb5 context. cache: The credential cache to store the creds into. creds: The credentials to store. """ def cc_switch( context: Context, cache: CCache, ) -> None: """Switch primary cache in a collection. If the type of cache supports it, set the cache to be the primary credential cache for the collection it belongs to. Args: context: Krb5 context. cache: The credential cache to set as the primary in its collection. """ def cc_get_config( context: Context, cache: CCache, principal: typing.Optional[Principal], key: bytes, ) -> bytes: """Get a configuration value from a credential cache. Args: context: Krb5 context. cache: The credential cache to get the data from. principal: The principal to get the configuration for or None for global values. key: Name of the variable. """ def cc_set_config( context: Context, cache: CCache, principal: typing.Optional[Principal], key: bytes, data: bytes, ) -> bytes: """Store a configuration value in a credential cache. Args: context: Krb5 context. cache: The credential cache to store the data in. principal: The principal to set the configuration for or None for global values. key: Name of the variable. data: Data to store or None to remove. """ pykrb5-0.8.0/src/krb5/_ccache.pyx000066400000000000000000000304771505521762700165210ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import enum import typing from libc.stdint cimport uintptr_t from krb5._exceptions import Krb5Error from krb5._principal import PrincipalParseFlags from krb5._context cimport Context from krb5._creds cimport Creds from krb5._krb5_types cimport * from krb5._principal cimport Principal cdef extern from "python_krb5.h": krb5_error_code krb5_cc_close( krb5_context context, krb5_ccache cache, ) nogil krb5_error_code krb5_cc_default( krb5_context context, krb5_ccache *cache, ) nogil const char *krb5_cc_default_name( krb5_context context, ) nogil krb5_error_code krb5_cc_destroy( krb5_context context, krb5_ccache cache, ) nogil krb5_error_code krb5_cc_end_seq_get( krb5_context context, krb5_ccache cache, krb5_cc_cursor *cursor, ) nogil krb5_error_code krb5_cc_initialize( krb5_context context, krb5_ccache cache, krb5_principal principal, ) nogil const char *krb5_cc_get_name( krb5_context context, krb5_ccache cache, ) nogil krb5_error_code krb5_cc_get_principal( krb5_context context, krb5_ccache cache, krb5_principal *principal, ) nogil const char *krb5_cc_get_type( krb5_context context, krb5_ccache cache, ) nogil krb5_error_code krb5_cc_new_unique( krb5_context context, const char *type, const char *hint, krb5_ccache *id, ) nogil krb5_error_code krb5_cc_next_cred( krb5_context context, krb5_ccache cache, krb5_cc_cursor *cursor, krb5_creds *cred, ) nogil krb5_error_code krb5_cc_remove_cred( krb5_context context, krb5_ccache cache, int flags, krb5_creds *creds, ) nogil krb5_error_code krb5_cc_resolve( krb5_context context, const char *name, krb5_ccache *cache, ) nogil krb5_error_code krb5_cc_retrieve_cred( krb5_context context, krb5_ccache cache, int flags, krb5_creds *mcreds, krb5_creds *creds, ) nogil krb5_error_code krb5_cc_set_default_name( krb5_context context, const char *name, ) nogil krb5_error_code krb5_cc_store_cred( krb5_context context, krb5_ccache cache, krb5_creds *creds, ) nogil krb5_error_code krb5_cc_start_seq_get( krb5_context context, krb5_ccache cache, krb5_cc_cursor *cursor, ) nogil krb5_error_code krb5_cc_switch( krb5_context context, krb5_ccache cache, ) nogil krb5_error_code krb5_cc_get_config( krb5_context context, krb5_ccache id, krb5_const_principal principal, const char *key, krb5_data *data, ); krb5_error_code krb5_cc_set_config( krb5_context context, krb5_ccache id, krb5_const_principal principal, const char *key, krb5_data *data, ) nogil int32_t KRB5_TC_MATCH_TIMES int32_t KRB5_TC_MATCH_IS_SKEY int32_t KRB5_TC_MATCH_FLAGS int32_t KRB5_TC_MATCH_TIMES_EXACT int32_t KRB5_TC_MATCH_FLAGS_EXACT int32_t KRB5_TC_MATCH_AUTHDATA int32_t KRB5_TC_MATCH_SRV_NAMEONLY int32_t KRB5_TC_MATCH_2ND_TKT int32_t KRB5_TC_MATCH_KTYPE int32_t KRB5_TC_SUPPORTED_KTYPES _CredentialsRetrieveFlags_members = [ ('none', 0), ('match_times', KRB5_TC_MATCH_TIMES), ('match_is_skey', KRB5_TC_MATCH_IS_SKEY), ('match_flags', KRB5_TC_MATCH_FLAGS), ('match_times_exact', KRB5_TC_MATCH_TIMES_EXACT), ('match_flags_exact', KRB5_TC_MATCH_FLAGS_EXACT), ('match_authdata', KRB5_TC_MATCH_AUTHDATA), ('match_srv_nameonly', KRB5_TC_MATCH_SRV_NAMEONLY), ('match_2nd_tkt', KRB5_TC_MATCH_2ND_TKT), ('match_keytype', KRB5_TC_MATCH_KTYPE), ] # If KRB5_TC_SUPPORTED_KTYPES is not available it will be set to 0 in # python_krb5.h if KRB5_TC_SUPPORTED_KTYPES != 0: _CredentialsRetrieveFlags_members += [ ('supported_ktypes', KRB5_TC_SUPPORTED_KTYPES), ] CredentialsRetrieveFlags = enum.IntEnum('CredentialsRetrieveFlags', _CredentialsRetrieveFlags_members) cdef class CCache: # cdef Context ctx # cdef krb5_ccache raw def __cinit__(CCache self, Context context): self.ctx = context self.raw = NULL def __dealloc__(CCache self): if self.raw: krb5_cc_close(self.ctx.raw, self.raw) self.raw = NULL def __iter__(CCache self) -> typing.Iterator[Creds]: cdef krb5_error_code err = 0 cdef krb5_cc_cursor cursor if self.raw == NULL: return err = krb5_cc_start_seq_get(self.ctx.raw, self.raw, &cursor) if err: raise Krb5Error(self.ctx, err) try: while True: creds = Creds(self.ctx) err = krb5_cc_next_cred( self.ctx.raw, self.raw, &cursor, creds.get_pointer(), ) if err: break creds.free_contents = 1 yield creds finally: err = krb5_cc_end_seq_get(self.ctx.raw, self.raw, &cursor) if err: raise Krb5Error(self.ctx, err) @property def addr(self) -> typing.Optional[int]: if self.raw: return self.raw @property def name(self) -> typing.Optional[bytes]: if self.raw: return cc_get_name(self.ctx, self) @property def principal(self) -> typing.Optional[Principal]: if self.raw: return cc_get_principal(self.ctx, self) @property def cache_type(self) -> typing.Optional[bytes]: if self.raw: return cc_get_type(self.ctx, self) def __repr__(CCache self) -> str: if self.raw: kwargs = [f"{k}={v}" for k, v in { 'cache_type': self.cache_type.decode('utf-8'), 'name': self.name.decode('utf-8'), }.items()] return f"CCache({', '.join(kwargs)})" else: return "CCache(NULL)" def __str__(CCache self) -> str: if self.raw: return f"{self.cache_type.decode('utf-8')}:{self.name.decode('utf-8')}" else: return "NULL" def cc_default( Context context not None, ) -> CCache: ccache = CCache(context) cdef krb5_error_code err = 0 err = krb5_cc_default(context.raw, &ccache.raw) if err: raise Krb5Error(context, err) return ccache def cc_default_name( Context context not None, ) -> bytes: return krb5_cc_default_name(context.raw) def cc_destroy( Context context not None, CCache cache not None, ) -> None: cdef krb5_error_code err = 0 err = krb5_cc_destroy(context.raw, cache.raw) if err: raise Krb5Error(context, err) cache.raw = NULL # Stops dealloc from calling close def cc_get_name( Context context not None, CCache cache not None, ) -> bytes: return krb5_cc_get_name(context.raw, cache.raw) def cc_get_principal( Context context not None, CCache cache not None, ) -> Principal: princ = Principal(context, PrincipalParseFlags.none) cdef krb5_error_code err = 0 err = krb5_cc_get_principal(context.raw, cache.raw, &princ.raw) if err: raise Krb5Error(context, err) return princ def cc_get_type( Context context not None, CCache cache not None, ) -> bytes: return krb5_cc_get_type(context.raw, cache.raw) def cc_initialize( Context context not None, CCache cache not None, Principal principal not None, ) -> None: cdef krb5_error_code err = 0 err = krb5_cc_initialize(context.raw, cache.raw, principal.raw) if err: raise Krb5Error(context, err) def cc_new_unique( Context context not None, const unsigned char[:] cred_type not None, const unsigned char[:] hint = None, ) -> CCache: ccache = CCache(context) cdef krb5_error_code err = 0 # TODO: Test that this cannot be NULL if not len(cred_type): raise ValueError("cred_type must be set to a valid type value not an empty byte string") cdef const char *hint_ptr = NULL if hint is not None and len(hint): hint_ptr = &hint[0] err = krb5_cc_new_unique(context.raw, &cred_type[0], hint_ptr, &ccache.raw) if err: raise Krb5Error(context, err) return ccache def cc_remove_cred( Context context not None, CCache cache not None, int flags, Creds creds not None, ) -> None: cdef krb5_error_code err = 0 err = krb5_cc_remove_cred( context.raw, cache.raw, flags, creds.get_pointer(), ) if err: raise Krb5Error(context, err) def cc_resolve( Context context not None, const unsigned char[:] name not None, ) -> CCache: ccache = CCache(context) cdef krb5_error_code err = 0 cdef const char *name_ptr = NULL if len(name): name_ptr = &name[0] else: raise ValueError("name cannot be an empty byte string") err = krb5_cc_resolve(context.raw, name_ptr, &ccache.raw) if err: raise Krb5Error(context, err) return ccache def cc_retrieve_cred( Context context not None, CCache cache not None, int flags, Creds mcreds not None, ) -> Creds: creds = Creds(context) cdef krb5_error_code err = 0 err = krb5_cc_retrieve_cred( context.raw, cache.raw, flags, mcreds.get_pointer(), creds.get_pointer()) if err: raise Krb5Error(context, err) creds.free_contents = 1 return creds def cc_set_default_name( Context context not None, const unsigned char[:] name, ) -> None: cdef krb5_error_code err = 0 cdef const char *name_ptr = NULL if name is not None and len(name): name_ptr = &name[0] err = krb5_cc_set_default_name(context.raw, name_ptr) if err: raise Krb5Error(context, err) def cc_store_cred( Context context not None, CCache cache not None, Creds creds not None, ) -> None: cdef krb5_error_code err = 0 err = krb5_cc_store_cred(context.raw, cache.raw, creds.get_pointer()) if err: raise Krb5Error(context, err) def cc_switch( Context context not None, CCache cache not None, ) -> None: cdef krb5_error_code err = 0 err = krb5_cc_switch(context.raw, cache.raw) if err: raise Krb5Error(context, err) def cc_get_config( Context context not None, CCache cache not None, Principal principal, const unsigned char[:] key not None, ) -> bytes: cdef krb5_error_code err = 0 cdef krb5_principal principal_raw = NULL if principal is not None: principal_raw = principal.raw cdef const char *key_ptr if len(key): key_ptr = &key[0] else: key_ptr = "" cdef krb5_data data err = krb5_cc_get_config(context.raw, cache.raw, principal_raw, key_ptr, &data) if err: raise Krb5Error(context, err) cdef size_t length cdef char *value pykrb5_get_krb5_data(&data, &length, &value) if length == 0: data_bytes = b"" else: data_bytes = value[:length] pykrb5_free_data_contents(context.raw, &data) return data_bytes def cc_set_config( Context context not None, CCache cache not None, Principal principal, const unsigned char[:] key not None, const unsigned char[:] data, ) -> None: cdef krb5_error_code err = 0 cdef krb5_principal principal_raw = NULL if principal is not None: principal_raw = principal.raw cdef const char *key_ptr if len(key): key_ptr = &key[0] else: key_ptr = "" cdef krb5_data data_raw cdef krb5_data* data_ptr if data is None: data_ptr = NULL else: if len(data) == 0: pykrb5_set_krb5_data(&data_raw, 0, "") else: pykrb5_set_krb5_data(&data_raw, len(data), &data[0]) data_ptr = &data_raw err = krb5_cc_set_config(context.raw, cache.raw, principal_raw, key_ptr, data_ptr) if err: raise Krb5Error(context, err) pykrb5-0.8.0/src/krb5/_ccache_match.pyi000066400000000000000000000012621505521762700176440ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._ccache import CCache from krb5._context import Context from krb5._principal import Principal def cc_cache_match( context: Context, principal: Principal, ) -> CCache: """Find a credential cache for the specified principal. Find a cache within the collection whose default principal is the same as the one specified. Args: context: Krb5 context. principal: The principal to find in the collection cache. Returns: CCache: The opened credential cache for the principal specified. """ pykrb5-0.8.0/src/krb5/_ccache_match.pyx000066400000000000000000000015001505521762700176560ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._exceptions import Krb5Error from krb5._ccache cimport CCache from krb5._context cimport Context from krb5._krb5_types cimport * from krb5._principal cimport Principal cdef extern from "python_krb5.h": # Added in MIT krb5 1.10 krb5_error_code krb5_cc_cache_match( krb5_context context, krb5_principal client, krb5_ccache *cache_out, ) nogil def cc_cache_match( Context context not None, Principal principal not None, ) -> CCache: ccache = CCache(context) cdef krb5_error_code err = 0 err = krb5_cc_cache_match(context.raw, principal.raw, &ccache.raw) if err: raise Krb5Error(context, err) return ccache pykrb5-0.8.0/src/krb5/_ccache_mit.pyi000066400000000000000000000010711505521762700173370ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._ccache import CCache from krb5._context import Context def cc_dup( context: Context, cache: CCache, ) -> CCache: """Duplicate ccache handle. Create a new handle referring to the same cache referenced. The new cache can be closed independently. Args: context: Krb5 context. cache: The credential cache to duplicate. Returns: CCache: The duplicated ccache. """ pykrb5-0.8.0/src/krb5/_ccache_mit.pyx000066400000000000000000000013051505521762700173560ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._exceptions import Krb5Error from krb5._ccache cimport CCache from krb5._context cimport Context from krb5._krb5_types cimport * cdef extern from "python_krb5.h": krb5_error_code krb5_cc_dup( krb5_context context, krb5_ccache in_cc, krb5_ccache *out, ) nogil def cc_dup( Context context not None, CCache cache not None, ) -> CCache: dup = CCache(context) cdef krb5_error_code err = 0 err = krb5_cc_dup(context.raw, cache.raw, &dup.raw) if err: raise Krb5Error(context, err) return dup pykrb5-0.8.0/src/krb5/_ccache_support_switch.pyi000066400000000000000000000012701505521762700216440ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._context import Context def cc_support_switch( context: Context, cache_type: bytes, ) -> bool: """Check whether the cache type supports switching. Checks whether the credential cache type specified supports switching the primary cache in its colleciton using :meth:`cc_switch`. Args: context: Krb5 context. cache_type: The credential cache type, like ``FILE``, ``DIR``, etc to check whether it supports switching or not. Returns: bool: The cache type supports switching. """ pykrb5-0.8.0/src/krb5/_ccache_support_switch.pyx000066400000000000000000000014151505521762700216640ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._exceptions import Krb5Error from krb5._context cimport Context from krb5._krb5_types cimport * cdef extern from "python_krb5.h": # Added in MIT 1.10 krb5_boolean krb5_cc_support_switch( krb5_context context, const char *type, ) nogil def cc_support_switch( Context context not None, const unsigned char[:] cache_type not None, ) -> bool: cdef const char *type_ptr = NULL if len(cache_type): type_ptr = &cache_type[0] else: raise ValueError("cache_type cannot be an empty byte string") return bool(krb5_cc_support_switch(context.raw, type_ptr)) pykrb5-0.8.0/src/krb5/_cccol.pyi000066400000000000000000000010101505521762700163340ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import typing from krb5._ccache import CCache from krb5._context import Context def cccol_iter( context: Context, ) -> typing.Iterator[CCache]: """Iterate over credential caches. Iterates over all known credential caches independent of type. Args: context: Krb5 context. Returns: Iterator[CCache]: An iterator of credential caches. """ pykrb5-0.8.0/src/krb5/_cccol.pyx000066400000000000000000000027611505521762700163710ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import typing from krb5._exceptions import Krb5Error from krb5._ccache cimport CCache from krb5._context cimport Context from krb5._krb5_types cimport * cdef extern from "python_krb5.h": krb5_error_code krb5_cccol_cursor_free( krb5_context context, krb5_cccol_cursor *cursor ) nogil krb5_error_code krb5_cccol_cursor_new( krb5_context context, krb5_cccol_cursor *cursor, ) nogil krb5_error_code krb5_cccol_cursor_next( krb5_context context, krb5_cccol_cursor cursor, krb5_ccache *ccache, ) nogil krb5_error_code KRB5_CC_END def cccol_iter( Context context not None, ) -> typing.Iterator[CCache]: cdef krb5_error_code err = 0 cdef krb5_context ctx = context.raw cdef krb5_cccol_cursor cursor err = krb5_cccol_cursor_new(ctx, &cursor) if err: raise Krb5Error(context, err) try: while True: ccache = CCache(context) err = krb5_cccol_cursor_next(ctx, cursor, &ccache.raw) if err == KRB5_CC_END: # Heimdal break elif err: raise Krb5Error(context, err) elif ccache.raw == NULL: # MIT break yield ccache finally: err = krb5_cccol_cursor_free(ctx, &cursor) if err: raise Krb5Error(context, err) pykrb5-0.8.0/src/krb5/_chpw_message_mit.pyi000066400000000000000000000014671505521762700206070ustar00rootroot00000000000000from krb5._context import Context def chpw_message(context: Context, server_response: bytes) -> bytes: """This function processes the byte sequence returned as the `server_response` by :meth:`set_password()` and :meth:`set_password_using_ccache()` functions, and returns a human readable byte string. Note that `gettext` library is used to translate the strings according to locale settings. For the list of existing translations, pls. refer to MIT krb5 source code. Not all translations may be available on your system. Caller is responsible for decoding the string according to locale settings. Args: context: Krb5 context. server_response: The `server_response` bytes received from the KDC. Returns: bytes: The human readable bytes string. """ pykrb5-0.8.0/src/krb5/_chpw_message_mit.pyx000066400000000000000000000023251505521762700206200ustar00rootroot00000000000000import typing from krb5._exceptions import Krb5Error from libc.string cimport strlen from krb5._context cimport Context from krb5._krb5_types cimport * cdef extern from "python_krb5.h": krb5_error_code krb5_chpw_message( krb5_context context, const krb5_data *server_string, char **message_out ) nogil void krb5_free_string( krb5_context context, char *string ) nogil def chpw_message( Context context not None, const unsigned char[:] server_string not None, ) -> bytes: cdef krb5_error_code err = 0 cdef krb5_data server_string_raw cdef char *message_out = NULL try: if len(server_string) == 0: pykrb5_set_krb5_data(&server_string_raw, 0, "") else: pykrb5_set_krb5_data(&server_string_raw, len(server_string), &server_string[0]) err = krb5_chpw_message(context.raw, &server_string_raw, &message_out) if err: raise Krb5Error(context, err) if message_out is NULL: return b"" else: message_len = strlen(message_out) return message_out[:message_len] finally: krb5_free_string(context.raw, message_out)pykrb5-0.8.0/src/krb5/_context.pxd000066400000000000000000000003331505521762700167360ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._krb5_types cimport * cdef class Context: cdef krb5_context raw pykrb5-0.8.0/src/krb5/_context.pyi000066400000000000000000000041541505521762700167510ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import typing class Context: """Kerberos Library Context This class represents a library context object. """ def init_context() -> Context: """Create a krb5 library context. Creates a krb5 library context. Returns: Context: The opened krb5 library context. """ def get_default_realm( context: Context, ) -> bytes: """Get default realm for the specified context. Returns the default realm of the context passed in. Args: context: Krb5 context. Returns: bytes: The default realm of the context. """ def set_default_realm( context: Context, realm: typing.Optional[bytes], ) -> None: """Override the default realm for the specified context. Sets the default realm of the passed in context to the value specified. Use ``None`` to clear out the existing explicit setting. Args: context: Krb5 context. realm: The realm to set as the default realm. """ def timeofday( context: Context, ) -> int: """Return the adjusted time. Return the adjusted time. Args: context: Krb5 context. Returns: The current time as seen by the KDC in seconds. """ def us_timeofday( context: Context, ) -> typing.Tuple[int, int]: """Return the adjusted time with microseconds. Return the adjusted time with microseconds. Args: context: Krb5 context. Returns: The current time as seen by the KDC in seconds and microseconds. """ def set_real_time( context: Context, seconds: int, microseconds: int, ) -> None: """Set the time offset to the difference between the system time and the specified time. Set the time offset of the context to the difference between the system time and the specified time. Args: context: Krb5 context. seconds: The seconds of the current time as seen by the KDC. microseconds: The microseconds of the current time as seen by the KDC or -1. """ pykrb5-0.8.0/src/krb5/_context.pyx000066400000000000000000000066631505521762700167770ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import typing from krb5._exceptions import Krb5Error from krb5._krb5_types cimport * cdef extern from "python_krb5.h": # krb5_free_default_realm is optionally exported in Heimdal (not at all on macOS) - use krb5_xfree instead """ void krb5_free_default_realm_generic(krb5_context context, char *realm) { #if defined(HEIMDAL_XFREE) krb5_xfree(realm); #else krb5_free_default_realm(context, realm); #endif } """ void krb5_free_context( krb5_context context, ) nogil krb5_error_code krb5_init_context( krb5_context *context, ) nogil # See inline C code void krb5_free_default_realm_generic( krb5_context context, char *realm, ) nogil krb5_error_code krb5_get_default_realm( krb5_context context, char **realm, ) nogil krb5_error_code krb5_set_default_realm( krb5_context context, const char *realm ) nogil krb5_error_code krb5_timeofday( krb5_context context, krb5_timestamp *seconds ) nogil krb5_error_code krb5_us_timeofday( krb5_context context, krb5_timestamp *seconds, int32_t *microseconds ) nogil krb5_error_code krb5_set_real_time( krb5_context context, krb5_timestamp seconds, int32_t microseconds ) nogil cdef class Context: # cdef krb5_context raw def __cinit__(Context self): self.raw = NULL def __dealloc__(Context self): if self.raw: krb5_free_context(self.raw) self.raw = NULL def __str__(Context self): return "Krb5Context" def init_context() -> Context: cdef krb5_error_code = 0 context = Context() err = krb5_init_context(&context.raw) if err: raise Krb5Error(context, err) return context def get_default_realm( Context context not None, ) -> bytes: cdef krb5_error_code = 0 cdef char *realm = NULL err = krb5_get_default_realm(context.raw, &realm) if err: raise Krb5Error(context, err) try: return realm finally: krb5_free_default_realm_generic(context.raw, realm) def set_default_realm( Context context not None, const unsigned char[:] realm, ) -> None: cdef krb5_error_code = 0 cdef const char *realm_ptr = NULL if realm is not None and len(realm): realm_ptr = &realm[0] err = krb5_set_default_realm(context.raw, realm_ptr) if err: raise Krb5Error(context, err) def timeofday( Context context not None, ) -> int: cdef krb5_error_code = 0 cdef krb5_timestamp seconds err = krb5_timeofday(context.raw, &seconds) if err: raise Krb5Error(context, err) return seconds def us_timeofday( Context context not None, ) -> typing.Tuple[int, int]: cdef krb5_error_code = 0 cdef krb5_timestamp seconds cdef int32_t microseconds err = krb5_us_timeofday(context.raw, &seconds, µseconds) if err: raise Krb5Error(context, err) return seconds, microseconds def set_real_time( Context context not None, int seconds, int microseconds, ) -> None: cdef krb5_error_code = 0 err = krb5_set_real_time(context.raw, seconds, microseconds) if err: raise Krb5Error(context, err) pykrb5-0.8.0/src/krb5/_context_mit.pyi000066400000000000000000000014301505521762700176140ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import typing from krb5._context import Context def init_secure_context() -> Context: """Create a secure krb5 library context. Create a context structure, using only system configuration files. All information passed through environment variables are ignored. Returns: Context: The opened krb5 library context. """ def get_time_offsets( context: Context, ) -> typing.Tuple[int, int]: """Return the time offset of the specified context. Returns the time offset of the specified context. Args: context: Krb5 context. Returns: The seconds and microseconds of the time offset. """ pykrb5-0.8.0/src/krb5/_context_mit.pyx000066400000000000000000000017361505521762700176440ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import typing from krb5._context cimport Context from krb5._exceptions import Krb5Error from krb5._krb5_types cimport * cdef extern from "python_krb5.h": krb5_error_code krb5_init_secure_context( krb5_context *context, ) nogil krb5_error_code krb5_get_time_offsets( krb5_context context, krb5_timestamp *seconds, int32_t *microseconds ) nogil def init_secure_context() -> Context: context = Context() krb5_init_secure_context(&context.raw) return context def get_time_offsets( Context context not None, ) -> typing.Tuple[int, int]: cdef krb5_error_code = 0 cdef krb5_timestamp seconds cdef int32_t microseconds err = krb5_get_time_offsets(context.raw, &seconds, µseconds) if err: raise Krb5Error(context, err) return seconds, microseconds pykrb5-0.8.0/src/krb5/_creds.pxd000066400000000000000000000010511505521762700163500ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._context cimport Context from krb5._krb5_types cimport * cdef class Creds: cdef Context ctx cdef int free_contents cdef krb5_creds* _raw cdef int _free_raw cdef void* set_raw_from_lib(Creds self, krb5_creds* raw) cdef krb5_creds *get_pointer(Creds self) cdef class InitCredsContext: cdef Context ctx cdef krb5_init_creds_context raw cdef class Krb5Prompt: pass pykrb5-0.8.0/src/krb5/_creds.pyi000066400000000000000000000212011505521762700163550ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import enum import typing from krb5._ccache import CCache from krb5._context import Context from krb5._creds_opt import GetInitCredsOpt from krb5._keyblock import KeyBlock from krb5._kt import KeyTab from krb5._principal import Principal class TicketTimes(typing.NamedTuple): authtime: int starttime: int endtime: int renew_till: int class TicketFlags(enum.IntFlag): """Kerberos ticket flags. See for the definition of the flags. The enc_pa_rep flag is defined by . The anonymous flag is defined by . """ reserved = 1 << 0 forwardable = 1 << 1 forwarded = 1 << 2 proxiable = 1 << 3 proxy = 1 << 4 may_postdate = 1 << 5 postdated = 1 << 6 invalid = 1 << 7 renewable = 1 << 8 initial = 1 << 9 pre_authent = 1 << 10 hw_authent = 1 << 11 transited_policy_checked = 1 << 12 ok_as_delegate = 1 << 13 enc_pa_rep = 1 << 15 anonymous = 1 << 16 class Creds: """Kerberos Credentials object. This class represents Kerberos credentials. Args: context: Krb5 context. """ @property def client(self) -> Principal: """Client's principal identifier.""" @property def server(self) -> Principal: """Server's principal identifier.""" @property def keyblock(self) -> KeyBlock: """Session encryption key info.""" @property def times(self) -> TicketTimes: """Lifetime info.""" @property def ticket_flags_raw(self) -> int: """Flags in ticket, as returned by libkrb5.""" @property def ticket_flags(self) -> TicketFlags: """Flags in ticket, converted to a representation where the first flag is in the lowermost bit.""" # @property # def addresses(self) -> Address: # """Addrs in ticket.""" @property def ticket(self) -> bytes: """Ticket string itself.""" @property def second_ticket(self) -> bytes: """second ticket, if related to ticket (via DUPLICATE-SKEY or ENC-TKT-IN-SKEY)""" # @property # def authdata(self) -> Authdata: # """authorization data""" class InitCredsContext: """Kerberos Initial Credentials object. This class represents Kerberos context for acquiring initial credentials. Args: context: Krb5 context. """ class Krb5Prompt: """Base class used to prompt the user for input. This is the base class the caller should use to create a prompter class that is passed into :meth:`get_init_creds_password` and :meth:`init_creds_init`. It is used to handle prompts from the Kerberos API, such as changing a password or password input. At a minimum the `prompt` function should be implemented to return the bytes for the prompt. """ def init( self, name: typing.Optional[bytes], banner: typing.Optional[bytes], num_prompts: int, ) -> None: """Initialise the prompt. Initialises the prompt by passing in the optional name, banner, and the number of prompts expected. Args: name: Optional name for the prompt session which should be displayed to the user. banner: Optional message that indicates what sort of input is expected from the user which should be displayed to the user. num_prompts: Number of times :meth:`prompt` is to be called for this prompt session. """ def prompt( self, msg: bytes, hidden: bool, ) -> bytes: """Prompt user for a response. Prompt the user for a response. Args: msg: The message to display for this prompt. hidden: Set to ``True`` to indicate the response should not be printed back to the user. Returns: bytes: The response for the prompt. """ def get_init_creds_keytab( context: Context, client: Principal, k5_gic_options: GetInitCredsOpt, keytab: KeyTab, start_time: int = 0, in_tkt_service: typing.Optional[bytes] = None, ) -> Creds: """Get initial credentials using a key table. Requests the KDC for credential using a client key stored in the key table specified. Args: context: Krb5 context. client: The client principal the credentials are for. k5_gic_options: The initial credentials options. keytab: The keytab to use when getting the credential. start_time: Time when the ticket becomes valid, 0 for now. in_tkt_service: The service name of the initial credentials. Returns: Creds: The retrieved credentials. """ def get_init_creds_password( context: Context, client: Principal, k5_gic_options: GetInitCredsOpt, password: typing.Optional[bytes] = None, start_time: int = 0, in_tkt_service: typing.Optional[bytes] = None, prompter: typing.Optional[Krb5Prompt] = None, ) -> Creds: """Get initial credential using a password. Requests the KDC for credentials using a password. Args: context: Krb5 context. client: The client principal the credentials are for. k5_gic_options: The initial credentials options. password: The password to use - set to ``None`` to use the prompter. start_time: Time when the ticket becomes valid, 0 for now. in_tkt_service: The service name of the initial credentials. prompter: The prompter instance that will handle interactive prompts. Returns: Creds: The retrieved credentials. """ def init_creds_get( context: Context, ctx: InitCredsContext, ) -> None: """Acquire credentials using initial creds context. Obtains credentials using the initial creds context from :meth:`init_creds_init`. The credentials can be retrieved with :meth:`init_creds_get_creds`. Args: context: Krb5 context. ctx: Initial credentials context. """ def init_creds_get_creds( context: Context, ctx: InitCredsContext, ) -> Creds: """Retreived acquired creds from an initial creds context. Gets the acquired creds from a successful call of :meth:`init_creds_get`. Args: context: Krb5 context. ctx: Initial credentials context. Returns: Creds: The acquired credentials. """ def init_creds_init( context: Context, client: Principal, k5_gic_options: typing.Optional[GetInitCredsOpt] = None, start_time: int = 0, prompter: typing.Optional[Krb5Prompt] = None, ) -> InitCredsContext: """Get initial acquiring credential context. Creates a new context used for acquiring initial credentials. Args: context: Krb5 context. client: The client principal the credentials are for. k5_gic_options: The initial credentials options. start_time: Time when the ticket becomes valid, 0 for now. prompter: The prompter instance that will handle interactive prompts. Returns: InitCredsContext: The retrieved acquiring initial credentials context. """ def init_creds_set_keytab( context: Context, ctx: InitCredsContext, keytab: KeyTab, ) -> None: """Set the keytab used for acquiring initial credentials. Sets the keytab used to contruct the client key for an initial credentials request. See :meth:`get_init_creds_keytab` for a simpler way to get credentials with a keytab. Args: context: Krb5 context. ctx: Initial credentials context. keytab: The keytab to set. """ def init_creds_set_password( context: Context, ctx: InitCredsContext, password: bytes, ) -> None: """Set the password used for acquiring initial credentials. Sets the password used to contruct the client key for an initial credentials request. See :meth:`get_init_creds_password` for a simpler way to get credentials with a password. Args: context: Krb5 context. ctx: Initial credentials context. password: The password to set. """ def get_renewed_creds( context: Context, client: Principal, ccache: CCache, in_tkt_service: typing.Optional[bytes] = None, ) -> Creds: """Get renewed credentials from the KDC. Args: context: Krb5 context. client: Client principal name. ccache: The cache to get the existing credentials from. in_tkt_service: Server principal string or None. """ pykrb5-0.8.0/src/krb5/_creds.pyx000066400000000000000000000405141505521762700164040ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import collections import enum import typing from krb5._exceptions import Krb5Error from krb5._keyblock import copy_keyblock from krb5._principal import copy_principal from libc.stdlib cimport calloc, free from krb5._ccache cimport CCache from krb5._context cimport Context from krb5._creds_opt cimport GetInitCredsOpt from krb5._keyblock cimport KeyBlock from krb5._krb5_types cimport * from krb5._kt cimport KeyTab from krb5._principal cimport Principal cdef extern from "python_krb5.h": """ void pykrb5_creds_get( krb5_creds *creds, krb5_principal *client, krb5_principal *server, krb5_keyblock **keyblock, pykrb5_ticket_times *times, uint32_t *ticket_flags_raw, uint32_t *ticket_flags, // krb5_address ***addresses, krb5_data *ticket, krb5_data *second_ticket // krb5_authdata ***authdata, ) { if (client != NULL) *client = creds->client; if (server != NULL) *server = creds->server; #if defined(HEIMDAL_XFREE) if (keyblock != NULL) *keyblock = &creds->session; #else if (keyblock != NULL) *keyblock = &creds->keyblock; #endif if (times != NULL) *times = creds->times; #if defined(HEIMDAL_XFREE) if (ticket_flags_raw != NULL) *ticket_flags_raw = creds->flags.i; if (ticket_flags != NULL) *ticket_flags = creds->flags.i; #else if (ticket_flags_raw != NULL) *ticket_flags_raw = creds->ticket_flags; if (ticket_flags != NULL) { *ticket_flags = 0; // Reverse the order of the bits to get the first bit in the // lowermost bit instead of in the uppermost bit. for (int i = 0; i < 32; i++) { if (creds->ticket_flags & (1 << (31 - i))) *ticket_flags |= (1 << i); } } #endif // if (addresses != NULL) *addresses = creds->addresses; if (ticket != NULL) *ticket = creds->ticket; if (second_ticket != NULL) *second_ticket = creds->second_ticket; // if (authdata != NULL) *authdata = creds->authdata; } """ void pykrb5_creds_get( krb5_creds *creds, krb5_principal *client, krb5_principal *server, krb5_keyblock **keyblock, pykrb5_ticket_times *times, uint32_t *ticket_flags_raw, uint32_t *ticket_flags, # krb5_address ***addresses, krb5_data *ticket, krb5_data *second_ticket, # krb5_authdata ***authdata, ) nogil void krb5_free_creds( krb5_context context, krb5_creds *val, ) nogil void krb5_free_cred_contents( krb5_context context, krb5_creds *val, ) nogil krb5_error_code krb5_init_creds_get( krb5_context context, krb5_init_creds_context ctx, ) nogil krb5_error_code krb5_init_creds_get_creds( krb5_context context, krb5_init_creds_context ctx, krb5_creds *creds, ) nogil krb5_error_code krb5_init_creds_init( krb5_context context, krb5_principal client, krb5_prompter_fct prompert, void *data, krb5_deltat start_time, krb5_get_init_creds_opt *options, krb5_init_creds_context *ctx, ) nogil krb5_error_code krb5_get_init_creds_keytab( krb5_context context, krb5_creds *creds, krb5_principal client, krb5_keytab arg_keytab, krb5_deltat start_time, const char *in_tkt_service, krb5_get_init_creds_opt *k5_gic_options, ) nogil void krb5_init_creds_free( krb5_context context, krb5_init_creds_context ctx, ) nogil krb5_error_code krb5_get_init_creds_password( krb5_context context, krb5_creds *creds, krb5_principal client, const char *password, krb5_prompter_fct prompter, void *data, krb5_deltat start_time, const char *in_tkt_service, krb5_get_init_creds_opt *k5_gic_options, ) nogil krb5_error_code krb5_init_creds_set_keytab( krb5_context context, krb5_init_creds_context ctx, krb5_keytab keytab, ) nogil krb5_error_code krb5_init_creds_set_password( krb5_context context, krb5_init_creds_context ctx, const char *password, ) nogil krb5_error_code krb5_get_renewed_creds( krb5_context context, krb5_creds *creds, krb5_principal client, krb5_ccache ccache, const char *in_tkt_service, ) nogil class TicketFlags(enum.IntFlag): # https://github.com/krb5/krb5-assignments/blob/master/ticket-flags reserved = 1 << 0 forwardable = 1 << 1 forwarded = 1 << 2 proxiable = 1 << 3 proxy = 1 << 4 may_postdate = 1 << 5 postdated = 1 << 6 invalid = 1 << 7 renewable = 1 << 8 initial = 1 << 9 pre_authent = 1 << 10 hw_authent = 1 << 11 transited_policy_checked = 1 << 12 ok_as_delegate = 1 << 13 enc_pa_rep = 1 << 15 anonymous = 1 << 16 # This is to prevent python >= 3.11 from clearing unknown flags when doing: # flags = flags & ~TicketFlags.forwarded # (Under python 3.11, ~TicketFlags.forwarded will contain only known flags.) _all_flags = (1 << 32) - 1 cdef class Creds: # cdef Context ctx # cdef int free_contents # cdef krb5_creds* _raw # cdef int _free_raw def __cinit__(Creds self, Context context): self.ctx = context self.free_contents = 0 self._raw = NULL self._free_raw = 0 def __dealloc__(Creds self): if not self._raw: return if self._free_raw: if self.free_contents: krb5_free_cred_contents(self.ctx.raw, self._raw) self.free_contents = 0 free(self._raw) else: krb5_free_creds(self.ctx.raw, self._raw) self._raw = NULL self._free_raw = 0 def __str__(Creds self) -> str: return "Creds" cdef void* set_raw_from_lib(Creds self, krb5_creds* raw): # This is called when the krb5_creds* was allocated by the krb5 lib. # We set the internal state so it calls krb5_free_creds properly on # deallocation. if self._raw: # This should never occur but it's here just in case raise ValueError("Cannot set raw pointer on already initialized Creds") self._raw = raw self._free_raw = 0 cdef krb5_creds *get_pointer(Creds self): # If this is being called without _raw being set we want to manage # the krb5_creds object in this class. if not self._raw: self._raw = calloc(sizeof(krb5_creds), 1) if not self._raw: raise MemoryError("Cannot calloc krb5_creds") self._free_raw = 1 return self._raw @property def client(Creds self) -> Principal: princ = Principal(self.ctx, 0, needs_free=0) pykrb5_creds_get(self.get_pointer(), &princ.raw, NULL, NULL, NULL, NULL, NULL, NULL, NULL) # Create a copy of the principal to make sure the returned value # remains valid even if the Creds object is destroyed princ_copy = copy_principal(self.ctx, princ) return princ_copy @property def server(Creds self) -> Principal: princ = Principal(self.ctx, 0, needs_free=0) pykrb5_creds_get(self.get_pointer(), NULL, &princ.raw, NULL, NULL, NULL, NULL, NULL, NULL) # Create a copy of the principal to make sure the returned value # remains valid even if the Creds object is destroyed princ_copy = copy_principal(self.ctx, princ) return princ_copy @property def keyblock(Creds self) -> KeyBlock: kb = KeyBlock(self.ctx, needs_free=0) pykrb5_creds_get(self.get_pointer(), NULL, NULL, &kb.raw, NULL, NULL, NULL, NULL, NULL) # Create a copy of the keyblock to make sure the returned value # remains valid even if the Creds object is destroyed kb_copy = copy_keyblock(self.ctx, kb) return kb_copy @property def times(Creds self) -> TicketTimes: cdef pykrb5_ticket_times times pykrb5_creds_get(self.get_pointer(), NULL, NULL, NULL, ×, NULL, NULL, NULL, NULL) return TicketTimes(times.authtime, times.starttime, times.endtime, times.renew_till) @property def ticket_flags_raw(Creds self) -> int: cdef uint32_t flags_raw pykrb5_creds_get(self.get_pointer(), NULL, NULL, NULL, NULL, &flags_raw, NULL, NULL, NULL) return flags_raw @property def ticket_flags(Creds self) -> TicketFlags: cdef uint32_t flags pykrb5_creds_get(self.get_pointer(), NULL, NULL, NULL, NULL, NULL, &flags, NULL, NULL) return TicketFlags(flags) @property def ticket(Creds self) -> bytes: cdef krb5_data ticket pykrb5_creds_get(self.get_pointer(), NULL, NULL, NULL, NULL, NULL, NULL, &ticket, NULL) cdef size_t length cdef char *value pykrb5_get_krb5_data(&ticket, &length, &value) if length == 0: return b"" else: return value[:length] @property def second_ticket(Creds self) -> bytes: cdef krb5_data second_ticket pykrb5_creds_get(self.get_pointer(), NULL, NULL, NULL, NULL, NULL, NULL, NULL, &second_ticket) cdef size_t length cdef char *value pykrb5_get_krb5_data(&second_ticket, &length, &value) if length == 0: return b"" else: return value[:length] cdef class InitCredsContext: # cdef Context ctx # cdef krb5_init_creds_context raw def __cinit__(InitCredsContext self, Context context): self.ctx = context self.raw = NULL def __dealloc__(InitCredsContext self): if self.raw: krb5_init_creds_free(self.ctx.raw, self.raw) self.raw = NULL def __str__(InitCredsContext self) -> str: return "InitCredsContext" cdef class Krb5Prompt: def init( self, name: typing.Optional[bytes], banner: typing.Optional[bytes], num_prompts: int, ) -> None: pass def prompt( self, msg: bytes, hidden: bool, ) -> bytes: raise NotImplementedError() cdef krb5_error_code prompt_callback( krb5_context context, void *data, const char *name, const char *banner, int num_prompts, krb5_prompt *prompts, ) noexcept with gil: try: prompter = data py_name = None if name == NULL else name py_banner = None if banner == NULL else banner prompter.init(py_name, py_banner, num_prompts) replies = [] for prompt in prompts[:num_prompts]: msg = prompt.prompt hidden = prompt.hidden != 0 reply = prompter.prompt(msg, hidden) if not isinstance(reply, bytes): return 1 replies.append(reply) for idx, reply in enumerate(replies): pykrb5_set_krb5_data(prompts[idx].reply, len(reply), reply) return 0 except Exception: return 1 def get_init_creds_keytab( Context context not None, Principal client not None, GetInitCredsOpt k5_gic_options not None, KeyTab keytab not None, int start_time = 0, const unsigned char[:] in_tkt_service = None, ) -> Creds: creds = Creds(context) cdef krb5_error_code err = 0 cdef krb5_creds* raw_creds = creds.get_pointer() cdef const char *in_tkt_service_ptr = NULL if in_tkt_service is not None and len(in_tkt_service): in_tkt_service_ptr = &in_tkt_service[0] with nogil: err = krb5_get_init_creds_keytab( context.raw, raw_creds, client.raw, keytab.raw, start_time, in_tkt_service_ptr, k5_gic_options.raw, ) if err: raise Krb5Error(context, err) creds.free_contents = 1 return creds def get_init_creds_password( Context context not None, Principal client not None, GetInitCredsOpt k5_gic_options not None, const unsigned char[:] password = None, int start_time = 0, const unsigned char[:] in_tkt_service = None, prompter: typing.Optional[Krb5Prompt] = None, ) -> Creds: creds = Creds(context) cdef krb5_error_code err = 0 cdef krb5_creds* raw_creds = creds.get_pointer() cdef const char *password_ptr = NULL if password is not None and len(password): password_ptr = &password[0] cdef krb5_prompter_fct callback = NULL cdef void *prompt_data = NULL if prompter is not None: callback = prompt_callback prompt_data = prompter cdef const char *in_tkt_service_ptr = NULL if in_tkt_service is not None and len(in_tkt_service): in_tkt_service_ptr = &in_tkt_service[0] with nogil: err = krb5_get_init_creds_password( context.raw, raw_creds, client.raw, password_ptr, callback, prompt_data, start_time, in_tkt_service_ptr, k5_gic_options.raw, ) if err: raise Krb5Error(context, err) creds.free_contents = 1 return creds def init_creds_get( Context context not None, InitCredsContext ctx not None, ) -> None: cdef krb5_error_code err = 0 with nogil: err = krb5_init_creds_get(context.raw, ctx.raw) if err: raise Krb5Error(context, err) def init_creds_get_creds( Context context not None, InitCredsContext ctx not None, ) -> Creds: creds = Creds(context) cdef krb5_error_code err = 0 err = krb5_init_creds_get_creds(context.raw, ctx.raw, creds.get_pointer()) if err: raise Krb5Error(context, err) creds.free_contents = 1 return creds def init_creds_init( Context context not None, Principal client not None, GetInitCredsOpt k5_gic_options = None, int start_time = 0, prompter: typing.Optional[Krb5Prompt] = None, ) -> InitCredsContext: creds_ctx = InitCredsContext(context) cdef krb5_error_code err = 0 cdef krb5_get_init_creds_opt *options = NULL if k5_gic_options: options = k5_gic_options.raw cdef krb5_prompter_fct callback = NULL cdef void *prompt_data = NULL if prompter is not None: callback = prompt_callback prompt_data = prompter with nogil: err = krb5_init_creds_init( context.raw, client.raw, callback, prompt_data, start_time, options, &creds_ctx.raw ) if err: raise Krb5Error(context, err) return creds_ctx def init_creds_set_keytab( Context context not None, InitCredsContext ctx not None, KeyTab keytab not None, ) -> None: cdef krb5_error_code err = 0 err = krb5_init_creds_set_keytab(context.raw, ctx.raw, keytab.raw) if err: raise Krb5Error(context, err) def init_creds_set_password( Context context not None, InitCredsContext ctx not None, const unsigned char[:] password, ) -> None: cdef krb5_error_code err = 0 cdef const char *password_ptr = NULL if password is not None and len(password): password_ptr = &password[0] else: raise ValueError("password must be set") err = krb5_init_creds_set_password(context.raw, ctx.raw, password_ptr) if err: raise Krb5Error(context, err) def get_renewed_creds( Context context not None, Principal client not None, CCache ccache not None, const unsigned char[:] in_tkt_service = None, ) -> Creds: creds = Creds(context) cdef krb5_error_code err = 0 cdef const char *in_tkt_service_ptr = NULL if in_tkt_service is not None and len(in_tkt_service): in_tkt_service_ptr = &in_tkt_service[0] err = krb5_get_renewed_creds( context.raw, creds.get_pointer(), client.raw, ccache.raw, in_tkt_service_ptr, ) if err: raise Krb5Error(context, err) creds.free_contents = 1 return creds TicketTimes = collections.namedtuple('TicketTimes', [ 'authtime', 'starttime', 'endtime', 'renew_till', ]) pykrb5-0.8.0/src/krb5/_creds_marshal_mit.pyi000066400000000000000000000021211505521762700207350ustar00rootroot00000000000000# Copyright: (c) 2024 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from __future__ import annotations from krb5._context import Context from krb5._creds import Creds def marshal_credentials( context: Context, creds: Creds, ) -> bytes: """Serialize creds. Serialize credentials in the format used by the FILE ccache format (version 4) and KCM ccache protocol. This is only present when compiled against MIT 1.20 or newer. Args: context: Krb5 context. creds: Credentials to serialize. Returns: bytes: The serialized credentials. """ def unmarshal_credentials( context: Context, data: bytes, ) -> Creds: """Deserialize creds. Deserialize credentials from the format used by the FILE ccache format (version 4) and KCM ccache protocol. This is only present when compiled against MIT 1.20 or newer. Args: context: Krb5 context. data: serialized credentials. Returns: Creds: The unserialized credentials. """ pykrb5-0.8.0/src/krb5/_creds_marshal_mit.pyx000066400000000000000000000041241505521762700207610ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) # These APIs were added in MIT 1.20, to be compat with 1.18 we need to define # them separately. import collections import typing from krb5._exceptions import Krb5Error from krb5._ccache cimport CCache from krb5._context cimport Context from krb5._creds cimport Creds from krb5._creds_opt cimport GetInitCredsOpt from krb5._krb5_types cimport * from krb5._principal cimport Principal cdef extern from "python_krb5.h": krb5_error_code krb5_marshal_credentials( krb5_context context, krb5_creds *creds, krb5_data **data ) nogil krb5_error_code krb5_unmarshal_credentials( krb5_context context, krb5_data *data, krb5_creds **creds, ) nogil void krb5_free_data( krb5_context context, krb5_data *val, ) nogil def marshal_credentials( Context context not None, Creds creds not None, ) -> bytes: cdef krb5_error_code err = 0 cdef krb5_data *data = NULL cdef size_t length cdef char *value try: err = krb5_marshal_credentials(context.raw, creds.get_pointer(), &data) if err: raise Krb5Error(context, err) pykrb5_get_krb5_data(data, &length, &value) if length == 0: data_bytes = b"" else: data_bytes = value[:length] return data_bytes finally: if NULL != data: krb5_free_data(context.raw, data) def unmarshal_credentials( Context context not None, const unsigned char[:] data not None, ) -> Creds: cdef krb5_error_code err = 0 cdef krb5_creds* raw_creds = NULL cdef krb5_data data_raw if len(data) == 0: pykrb5_set_krb5_data(&data_raw, 0, "") else: pykrb5_set_krb5_data(&data_raw, len(data), &data[0]) err = krb5_unmarshal_credentials(context.raw, &data_raw, &raw_creds) if err: raise Krb5Error(context, err) creds = Creds(context) creds.set_raw_from_lib(raw_creds) return creds pykrb5-0.8.0/src/krb5/_creds_mit.pyi000066400000000000000000000027421505521762700172370ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import typing from krb5._ccache import CCache from krb5._context import Context from krb5._creds import Creds from krb5._creds_opt import GetInitCredsOpt from krb5._principal import Principal class EtypeInfo(typing.NamedTuple): etype: int salt: typing.Optional[bytes] s2kparams: typing.Optional[bytes] def get_validated_creds( context: Context, client: Principal, ccache: CCache, in_tkt_service: typing.Optional[bytes] = None, ) -> Creds: """Get validated credentials from the KDC for a postdated ticket. Args: context: Krb5 context. client: Client principal name. ccache: The cache to get the existing credentials from. in_tkt_service: Server principal string or None. """ def get_etype_info( context: Context, principal: Principal, opt: typing.Optional[GetInitCredsOpt] = None, ) -> EtypeInfo: """Retrieve the enctype, salt and s2kparams for a principal from the KDC. Args: context: Krb5 context. principal: Principal to fetch the information for. opt: Options to use (e.g. for FAST armoring). Returns: A named tuple containing the enctype, the salt and the s2kparams. If the KDC provides no etype-info, the returned salt is None. If there are no s2kparams in the provided etype-info, s2kparams is None. """ pykrb5-0.8.0/src/krb5/_creds_mit.pyx000066400000000000000000000063241505521762700172560ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import collections import typing from krb5._exceptions import Krb5Error from krb5._ccache cimport CCache from krb5._context cimport Context from krb5._creds cimport Creds from krb5._creds_opt cimport GetInitCredsOpt from krb5._krb5_types cimport * from krb5._principal cimport Principal cdef extern from "python_krb5.h": krb5_error_code krb5_get_validated_creds( krb5_context context, krb5_creds *creds, krb5_principal client, krb5_ccache ccache, const char *in_tkt_service, ) nogil krb5_error_code krb5_get_etype_info( krb5_context context, krb5_principal principal, krb5_get_init_creds_opt *opt, krb5_enctype *enctype_out, krb5_data *salt_out, krb5_data *s2kparams_ou, ) nogil EtypeInfo = collections.namedtuple('EtypeInfo', [ 'etype', 'salt', 's2kparams', ]) def get_validated_creds( Context context not None, Principal client not None, CCache ccache not None, const unsigned char[:] in_tkt_service = None, ) -> Creds: creds = Creds(context) cdef krb5_error_code err = 0 cdef const char *in_tkt_service_ptr = NULL if in_tkt_service is not None and len(in_tkt_service): in_tkt_service_ptr = &in_tkt_service[0] err = krb5_get_validated_creds( context.raw, creds.get_pointer(), client.raw, ccache.raw, in_tkt_service_ptr) if err: raise Krb5Error(context, err) creds.free_contents = 1 return creds def get_etype_info( Context context not None, Principal principal not None, GetInitCredsOpt opt = None, ) -> EtypeInfo: cdef krb5_error_code err = 0 cdef krb5_get_init_creds_opt *options = NULL if opt: options = opt.raw cdef krb5_enctype enctype cdef krb5_data salt cdef krb5_data s2kparams with nogil: err = krb5_get_etype_info( context.raw, principal.raw, options, &enctype, &salt, &s2kparams, ) if err: raise Krb5Error(context, err) cdef size_t length cdef char *value pykrb5_get_krb5_data(&salt, &length, &value) if length == 0: if enctype == 0: # ENCTYPE_NULL # If enctype is ENCTYPE_NULL and the salt is empty this means that # the KDC provided no etype-info. Return None in this case. salt_bytes = None else: salt_bytes = b"" else: salt_bytes = value[:length] pykrb5_free_data_contents(context.raw, &salt) pykrb5_get_krb5_data(&s2kparams, &length, &value) if length == 0: # This means that the KDC provided an etype-info without s2kparams # (PA-ETYPE-INFO instead of PA-ETYPE-INFO2). # Return None instead of b'' in this case so that the value can be # passed directly to krb.c_string_to_key() s2kparams_bytes = None else: s2kparams_bytes = value[:length] pykrb5_free_data_contents(context.raw, &s2kparams) return EtypeInfo(enctype, salt_bytes, s2kparams_bytes) pykrb5-0.8.0/src/krb5/_creds_opt.pxd000066400000000000000000000004471505521762700172420ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._context cimport Context from krb5._krb5_types cimport * cdef class GetInitCredsOpt: cdef Context ctx cdef krb5_get_init_creds_opt *raw pykrb5-0.8.0/src/krb5/_creds_opt.pyi000066400000000000000000000077061505521762700172550ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import typing from krb5._context import Context class GetInitCredsOpt: """Kerberos Initial Credential Options object. This class represents an initial credential options object. Args: context: Krb5 context. """ def get_init_creds_opt_alloc( context: Context, ) -> GetInitCredsOpt: """Allocate a new initial credential options object. Creates a new options structure that control how credential are gotten. Args: context: Krb5 context. Returns: GetInitCredsOpt: The initial credential options object. """ def get_init_creds_opt_set_anonymous( opt: GetInitCredsOpt, anonymous: bool, ) -> None: """Set anonymous details in the initial credential options. This function may be used to request anonymous credentials from the KDC. Note: Anonymous credentials are only a request; clients must verify that credentials are anonymous if that is a requirement. Args: opt: The initial credential options. anonymous: Whether to set or unset the anonymous option. """ def get_init_creds_opt_set_canonicalize( opt: GetInitCredsOpt, canonicalize: bool, ) -> None: """Set canonicalization details in the initial credential options. Sets whether the credential client principal should be canonicalized by the KDC. Args: opt: The initial credential options. canonicalize: Whether to set or unset the canonicalize option. """ def get_init_creds_opt_set_etype_list( opt: GetInitCredsOpt, etypes: typing.Iterable[int], ) -> None: """Set allowable encryptions types in the initial credential options. Sets the allowable encryption types in the initial credential options. Use :meth:`string_to_enctype` to convert an encryption type string to the int identifier. Args: opt: The initial credential options. etypes: The list of allowable encryption types. """ def get_init_creds_opt_set_forwardable( opt: GetInitCredsOpt, forwardable: bool, ) -> None: """Set forwardable details in the initial credential options. Sets whether the credentials are to be forwardable or not. Args: opt: The initial credential options. forwardable: Whether to set or unset the forwardable option. """ def get_init_creds_opt_set_proxiable( opt: GetInitCredsOpt, proxiable: bool, ) -> None: """Set proxiable details in the initial credential options. Sets whether the credentials are to be proxiable or not. Args: opt: The initial credential options. proxiable: Whether to set or unset the proxiable option. """ def get_init_creds_opt_set_renew_life( opt: GetInitCredsOpt, renew_life: int, ) -> None: """Set the ticket renewal lifetime. Sets the ticket renewal lifetime in seconds in the initial credential options. Args: opt: The initial credential options. renew_life: The ticket renewal lifetime in seconds. """ def get_init_creds_opt_set_salt( opt: GetInitCredsOpt, salt: bytes, ) -> None: """Set salt for optimistic preauth in initial credential options. When getting initial credentials with a password, a salt string it used to convert the password to a key. Normally this salt is obtained from the first KDC reply, but when performing optimistic preauthentication, the client may need to supply the salt string with this function. Args: opt: The initial credential options. salt: The salt to set. """ def get_init_creds_opt_set_tkt_life( opt: GetInitCredsOpt, tkt_life: int, ) -> None: """Set the ticket lifetime. Sets the ticket lifetime in seconds in the initial credential options. Args: opt: The initial credential options. tkt_life: The ticket lifetime in seconds. """ pykrb5-0.8.0/src/krb5/_creds_opt.pyx000066400000000000000000000114761505521762700172730ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import typing from libc.stdlib cimport free, malloc from krb5._exceptions import Krb5Error from krb5._context cimport Context from krb5._krb5_types cimport * cdef extern from "python_krb5.h": # Heimdal requires the context arg whereas MIT does not. """ void krb5_get_init_creds_opt_set_canonicalize_generic(krb5_context context, krb5_get_init_creds_opt *opt, int canonicalize) { #if defined(HEIMDAL_XFREE) krb5_get_init_creds_opt_set_canonicalize(context, opt, (krb5_boolean)canonicalize); #else krb5_get_init_creds_opt_set_canonicalize(opt, canonicalize); #endif } """ krb5_error_code krb5_get_init_creds_opt_alloc( krb5_context context, krb5_get_init_creds_opt **opt, ) nogil void krb5_get_init_creds_opt_set_anonymous( krb5_get_init_creds_opt *opt, int anonymous, ) nogil void krb5_get_init_creds_opt_free( krb5_context context, krb5_get_init_creds_opt *opt, ) nogil void krb5_get_init_creds_opt_set_canonicalize_generic( krb5_context context, krb5_get_init_creds_opt *opt, int canonicalize, ) nogil void krb5_get_init_creds_opt_set_etype_list( krb5_get_init_creds_opt *opt, krb5_enctype *etype_list, int etype_list_length, ) nogil void krb5_get_init_creds_opt_set_forwardable( krb5_get_init_creds_opt *opt, int forwardable, ) nogil void krb5_get_init_creds_opt_set_proxiable( krb5_get_init_creds_opt *opt, int proxiable, ) nogil void krb5_get_init_creds_opt_set_renew_life( krb5_get_init_creds_opt *opt, krb5_deltat renew_life, ) nogil void krb5_get_init_creds_opt_set_salt( krb5_get_init_creds_opt *opt, krb5_data *salt, ) nogil void krb5_get_init_creds_opt_set_tkt_life( krb5_get_init_creds_opt *opt, krb5_deltat tkt_life, ) nogil cdef class GetInitCredsOpt: # cdef Context ctx # cdef krb5_get_init_creds_opt *raw def __cinit__(GetInitCredsOpt self, Context context): self.ctx = context self.raw = NULL def __dealloc__(GetInitCredsOpt self): if self.raw: krb5_get_init_creds_opt_free(self.ctx.raw, self.raw) self.raw = NULL def __str__(GetInitCredsOpt self): return "GetInitCredsOpt" def get_init_creds_opt_alloc( Context context not None, ) -> GetInitCredsOpt: opt = GetInitCredsOpt(context) cdef krb5_error_code err = 0 err = krb5_get_init_creds_opt_alloc(context.raw, &opt.raw) if err: raise Krb5Error(context, err) return opt def get_init_creds_opt_set_anonymous( GetInitCredsOpt opt not None, anonymous: bool, ) -> None: cdef int value = 1 if anonymous else 0 krb5_get_init_creds_opt_set_anonymous(opt.raw, value) def get_init_creds_opt_set_canonicalize( GetInitCredsOpt opt not None, canonicalize: bool, ) -> None: cdef int value = 1 if canonicalize else 0 krb5_get_init_creds_opt_set_canonicalize_generic(opt.ctx.raw, opt.raw, value) def get_init_creds_opt_set_etype_list( GetInitCredsOpt opt not None, etypes: typing.Iterable[int], ) -> None: tmp = list(etypes) cdef krb5_enctype *buffer = malloc(len(etypes) * sizeof(krb5_enctype)) if not buffer: raise MemoryError() for idx, e in enumerate(tmp): buffer[idx] = tmp[idx] krb5_get_init_creds_opt_set_etype_list(opt.raw, buffer, len(etypes)) def get_init_creds_opt_set_forwardable( GetInitCredsOpt opt not None, forwardable: bool, ) -> None: cdef int value = 1 if forwardable else 0 krb5_get_init_creds_opt_set_forwardable(opt.raw, value) def get_init_creds_opt_set_proxiable( GetInitCredsOpt opt not None, proxiable: bool, ) -> None: cdef int value = 1 if proxiable else 0 krb5_get_init_creds_opt_set_proxiable(opt.raw, value) def get_init_creds_opt_set_renew_life( GetInitCredsOpt opt not None, krb5_deltat renew_life, ) -> None: krb5_get_init_creds_opt_set_renew_life(opt.raw, renew_life) def get_init_creds_opt_set_salt( GetInitCredsOpt opt not None, const unsigned char[:] salt not None, ) -> None: if not len(salt): raise ValueError("salt cannot be an empty byte string") cdef krb5_data buffer pykrb5_set_krb5_data(&buffer, len(salt), &salt[0]) krb5_get_init_creds_opt_set_salt(opt.raw, &buffer) def get_init_creds_opt_set_tkt_life( GetInitCredsOpt opt not None, krb5_deltat tkt_life, ) -> None: krb5_get_init_creds_opt_set_tkt_life(opt.raw, tkt_life) pykrb5-0.8.0/src/krb5/_creds_opt_heimdal.pyi000066400000000000000000000014201505521762700207230ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import typing from krb5._context import Context from krb5._creds_opt import GetInitCredsOpt def get_init_creds_opt_set_default_flags( context: Context, opt: GetInitCredsOpt, appname: typing.Optional[bytes] = None, realm: typing.Optional[bytes] = None, ) -> None: """Set default configuration file flags. Set all the values in the options to the default values for the app and realm. Args: context: Krb5 context. ccache: The credential cache to set as the output. appname: The application name to get the default values for. realm: The realm as a fallback from appname. """ pykrb5-0.8.0/src/krb5/_creds_opt_heimdal.pyx000066400000000000000000000020521505521762700207440ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._exceptions import Krb5Error from krb5._context cimport Context from krb5._creds_opt cimport GetInitCredsOpt from krb5._krb5_types cimport * cdef extern from "python_krb5.h": void krb5_get_init_creds_opt_set_default_flags( krb5_context context, const char *appname, const char *realm, krb5_get_init_creds_opt *opt, ) nogil def get_init_creds_opt_set_default_flags( Context context not None, GetInitCredsOpt opt not None, const unsigned char[:] appname = None, const unsigned char[:] realm = None, ) -> None: cdef const char *appname_ptr = NULL if appname is not None and len(appname): appname_ptr = &appname[0] cdef const char *realm_ptr = NULL if realm is not None and len(realm): realm_ptr = &realm[0] krb5_get_init_creds_opt_set_default_flags(context.raw, appname_ptr, realm_ptr, opt.raw) pykrb5-0.8.0/src/krb5/_creds_opt_mit.pyi000066400000000000000000000057411505521762700201230ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import enum import typing from krb5._ccache import CCache from krb5._context import Context from krb5._creds_opt import GetInitCredsOpt class FastFlags(enum.IntEnum): """Flags used to control :meth:`get_init_creds_opt_set_fast_flags`.""" none = ... #: No flags set. required = ... #: Require KDC to support FAST. def get_init_creds_opt_set_fast_ccache( context: Context, opt: GetInitCredsOpt, ccache: CCache, ) -> None: """Set FAST armor cache in options using an explicit CCache. Sets the location of the FAST armor ccache in the initial credential options. This is like :meth:`get_init_creds_opt_set_fast_ccache_name` except the ccache is provided as a CCache object rather than by name. Args: context: Krb5 context. opt: The initial credential options. ccache: The credential cache to set. """ def get_init_creds_opt_set_fast_ccache_name( context: Context, opt: GetInitCredsOpt, name: bytes, ) -> None: """Set FAST armor ccache in options using a name. Sets the location of the FAST armor ccache in initial credential options, This cache should contain the armor ticket to protect an initial credential exchange using the FAST protocol extension. Setting this option causes FAST to be used if the KDC supports it. Use :meth:`get_init_creds_opt_set_fast_flags` to mandate that FAST be used. Args: context: Krb5 context. opt: The initial credential options. name: The name of the credential cache. """ def get_init_creds_opt_set_fast_flags( context: Context, opt: GetInitCredsOpt, flags: typing.Union[int, FastFlags], ) -> None: """Set FAST flags in initial credential options. Sets the FAST flags in the initial credential options. Args: context: Krb5 context. opt: The initial credential options. flags: The flags to set. """ def get_init_creds_opt_set_out_ccache( context: Context, opt: GetInitCredsOpt, ccache: CCache, ) -> None: """Set output credential cache in options. Sets the output credential cache in the credential option structure. Args: context: Krb5 context. opt: The initial credential options. ccache: The credential cache to set as the output. """ def get_init_creds_opt_set_pa( context: Context, opt: GetInitCredsOpt, attr: bytes, value: bytes, ) -> None: """Supply options for preauth in initial credential options. This function allows the caller to supply options for preauthentication. The values of attr and value are supplied to each preauthentication module available within context. Args: context: Krb5 ontext. opt: The initial credential options. attr: The preauthentication option name. value: The preauthentication option value. """ pykrb5-0.8.0/src/krb5/_creds_opt_mit.pyx000066400000000000000000000065251505521762700201430ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import enum from krb5._exceptions import Krb5Error from krb5._ccache cimport CCache from krb5._context cimport Context from krb5._creds_opt cimport GetInitCredsOpt from krb5._krb5_types cimport * cdef extern from "python_krb5.h": krb5_error_code krb5_get_init_creds_opt_set_fast_ccache( krb5_context context, krb5_get_init_creds_opt *opt, krb5_ccache ccache, ) nogil krb5_error_code krb5_get_init_creds_opt_set_fast_flags( krb5_context context, krb5_get_init_creds_opt *opt, krb5_int32 flags, ) nogil krb5_error_code krb5_get_init_creds_opt_set_fast_ccache_name( krb5_context context, krb5_get_init_creds_opt *opt, const char *fast_ccache_name, ) nogil krb5_error_code krb5_get_init_creds_opt_set_out_ccache( krb5_context context, krb5_get_init_creds_opt *opt, krb5_ccache ccache, ) nogil krb5_error_code krb5_get_init_creds_opt_set_pa( krb5_context context, krb5_get_init_creds_opt *opt, const char *attr, const char *value, ) nogil int32_t KRB5_FAST_REQUIRED class FastFlags(enum.IntEnum): none = 0 required = KRB5_FAST_REQUIRED def get_init_creds_opt_set_fast_ccache( Context context not None, GetInitCredsOpt opt not None, CCache ccache not None, ) -> None: cdef krb5_error_code err = 0 err = krb5_get_init_creds_opt_set_fast_ccache(context.raw, opt.raw, ccache.raw) if err: raise Krb5Error(context, err) def get_init_creds_opt_set_fast_flags( Context context not None, GetInitCredsOpt opt not None, krb5_int32 flags, ) -> None: cdef krb5_error_code err = 0 err = krb5_get_init_creds_opt_set_fast_flags(context.raw, opt.raw, flags) if err: raise Krb5Error(context, err) def get_init_creds_opt_set_fast_ccache_name( Context context not None, GetInitCredsOpt opt not None, const unsigned char[:] name not None, ) -> None: cdef krb5_error_code err = 0 cdef const char *name_ptr = NULL if len(name): name_ptr = &name[0] else: raise ValueError("CCache name must be set") err = krb5_get_init_creds_opt_set_fast_ccache_name(context.raw, opt.raw, name_ptr) if err: raise Krb5Error(context, err) def get_init_creds_opt_set_out_ccache( Context context not None, GetInitCredsOpt opt not None, CCache ccache not None, ) -> None: cdef krb5_error_code err = 0 err = krb5_get_init_creds_opt_set_out_ccache(context.raw, opt.raw, ccache.raw) if err: raise Krb5Error(context, err) def get_init_creds_opt_set_pa( Context context not None, GetInitCredsOpt opt not None, const unsigned char[:] attr not None, const unsigned char[:] value not None, ) -> None: cdef krb5_error_code err = 0 cdef char *attr_ptr if len(attr): attr_ptr = &attr[0] else: raise ValueError("attr must be set") cdef char *value_ptr if len(value): value_ptr = &value[0] else: raise ValueError("value must be set") err = krb5_get_init_creds_opt_set_pa(context.raw, opt.raw, attr_ptr, value_ptr) if err: raise Krb5Error(context, err) pykrb5-0.8.0/src/krb5/_creds_opt_set_in_ccache.pyi000066400000000000000000000017531505521762700221000ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._ccache import CCache from krb5._context import Context from krb5._creds_opt import GetInitCredsOpt def get_init_creds_opt_set_in_ccache( context: Context, opt: GetInitCredsOpt, ccache: CCache, ) -> None: """Set an input credential cache in initial credential options. If an input credential cache is set, then the krb5_get_init_creds family of APIs will read settings from it. Setting an input ccache is desirable when the application wishes to perform authentication in the same way (using the same preauthentication mechanisms, and making the same non-security sensitive choices) as the previous authentication attempt, which stored information in the passed-in cache. Args: context: Krb5 context. opt: The initial credential options. ccache: The credential cache to set. """ pykrb5-0.8.0/src/krb5/_creds_opt_set_in_ccache.pyx000066400000000000000000000015041505521762700221110ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._exceptions import Krb5Error from krb5._ccache cimport CCache from krb5._context cimport Context from krb5._creds_opt cimport GetInitCredsOpt from krb5._krb5_types cimport * cdef extern from "python_krb5.h": krb5_error_code krb5_get_init_creds_opt_set_in_ccache( krb5_context context, krb5_get_init_creds_opt *opt, krb5_ccache ccache, ) nogil def get_init_creds_opt_set_in_ccache( Context context not None, GetInitCredsOpt opt not None, CCache ccache not None, ) -> None: cdef krb5_error_code err = 0 err = krb5_get_init_creds_opt_set_in_ccache(context.raw, opt.raw, ccache.raw) if err: raise Krb5Error(context, err) pykrb5-0.8.0/src/krb5/_creds_opt_set_pac_request.pyi000066400000000000000000000015711505521762700225150ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._context import Context from krb5._creds_opt import GetInitCredsOpt def get_init_creds_opt_set_pac_request( context: Context, opt: GetInitCredsOpt, req_pac: bool, ) -> None: """Ask KDC to include or not include a PAC in the ticket. If this option is set, the AS request will include a PAC-REQUEST pa-data item explicitly asking the KDC to either include or include a privilege attribute certificate in the ticket authorization data. By default, no request is made; typically the KDC will default to including a PAC if it supports them. Args: context: Krb5 context. opt: The initial credential options. canonicalize: Whether to set or unset the canonicalize option. """ pykrb5-0.8.0/src/krb5/_creds_opt_set_pac_request.pyx000066400000000000000000000013741505521762700225350ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import typing from krb5._exceptions import Krb5Error from krb5._context cimport Context from krb5._creds_opt cimport GetInitCredsOpt from krb5._krb5_types cimport * cdef extern from "python_krb5.h": krb5_error_code krb5_get_init_creds_opt_set_pac_request( krb5_context context, krb5_get_init_creds_opt *opt, krb5_boolean req_pac, ) nogil def get_init_creds_opt_set_pac_request( Context context not None, GetInitCredsOpt opt not None, req_pac: bool, ) -> None: cdef int value = 1 if req_pac else 0 krb5_get_init_creds_opt_set_pac_request(context.raw, opt.raw, value) pykrb5-0.8.0/src/krb5/_exceptions.pyi000066400000000000000000000006021505521762700174400ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._context import Context class Krb5Error(Exception): """Base Keberos Error class.""" def __init__( self, context: Context, err_code: int, ) -> None: ... err_code: int #: The Kerberos error code. pykrb5-0.8.0/src/krb5/_exceptions.pyx000066400000000000000000000021261505521762700174620ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from libc.stdint cimport int32_t from krb5._context cimport Context from krb5._krb5_types cimport * cdef extern from "python_krb5.h": const char *krb5_get_error_message( krb5_context ctx, krb5_error_code code, ) nogil void krb5_free_error_message( krb5_context ctx, const char *msg, ) nogil krb5_error_code KRB5_KT_NAME_TOOLONG # krb5_error_code KRB5_CONFIG_NOTENUFSPACE cdef str get_error_message( krb5_context ctx, krb5_error_code err, ): cdef const char *err_msg = NULL err_msg = krb5_get_error_message(ctx, err) try: return err_msg.decode('utf-8') finally: krb5_free_error_message(ctx, err_msg) class Krb5Error(Exception): def __init__( self, context: Context, err_code: int, ) -> None: self.err_code = err_code msg = get_error_message(context.raw, err_code) super().__init__(f"{msg} {self.err_code}") pykrb5-0.8.0/src/krb5/_keyblock.pxd000066400000000000000000000004561505521762700170630ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._context cimport Context from krb5._krb5_types cimport * cdef class KeyBlock: cdef Context ctx cdef krb5_keyblock *raw cdef int needs_free pykrb5-0.8.0/src/krb5/_keyblock.pyi000066400000000000000000000025461505521762700170730ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import typing from krb5._context import Context class KeyBlock: """Kerberos KeyBlock This class represents the contents of a key. Args: context: Krb5 context. """ def __len__(self) -> int: ... @property def data(self) -> bytes: """The keyblock data.""" @property def enctype(self) -> int: """The keyblock encryption type.""" def init_keyblock( context: Context, enctype: int, key: typing.Optional[bytes], ) -> KeyBlock: """Initialize a Key Block. Initalize a new keyblock and copy the key into the contents of that block. The key can be None or an empty byte string to represent the contents are not allocated. Args: context: Krb5 context. enctype: The encryption type of the keyblock. key: The data to place in the keyblock or None for an empty block. Returns: KeyBlock: The initialized keyblock. """ def copy_keyblock( context: Context, keyblock: KeyBlock, ) -> KeyBlock: """Copy a keyblock. Create a copy of the keyblock specified. Args: context: Krb5 context. keyblock: The keyblock to copy. Returns: KeyBlock: The copy of the keyblock. """ pykrb5-0.8.0/src/krb5/_keyblock.pyx000066400000000000000000000106021505521762700171020ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from libc.stdlib cimport free from krb5._exceptions import Krb5Error from krb5._context cimport Context from krb5._krb5_types cimport * cdef extern from "python_krb5.h": # MIT and Heimdal have slightly different functions to init a keyblock """ void pykrb5_keyblock_get( krb5_keyblock *key, krb5_enctype *enctype, size_t *length, char **data ) { #if defined(HEIMDAL_XFREE) if (enctype != NULL) *enctype = key->keytype; if (length != NULL) *length = key->keyvalue.length; if (data != NULL) *data = key->keyvalue.data; #else if (enctype != NULL) *enctype = key->enctype; if (length != NULL) *length = key->length; if (data != NULL) *data = (char *)key->contents; #endif } krb5_error_code krb5_init_keyblock_generic( krb5_context context, krb5_enctype enctype, size_t length, const char *data, krb5_keyblock **out ) { #if defined(HEIMDAL_XFREE) // While initialised here, krb5_free_keyblock will free this on deallocation krb5_keyblock *keyblock = NULL; keyblock = malloc(sizeof(krb5_keyblock)); if (keyblock == NULL) { return ENOMEM; } *out = keyblock; return krb5_keyblock_init(context, enctype, data, length, keyblock); #else krb5_error_code err = 0; err = krb5_init_keyblock(context, enctype, length, out); if (err == 0 && length > 0) { memcpy((*out)->contents, data, length); } return err; #endif } """ krb5_error_code krb5_init_keyblock_generic( krb5_context context, krb5_enctype enctype, size_t length, const char *data, krb5_keyblock **out, ) nogil krb5_error_code krb5_free_keyblock( krb5_context context, krb5_keyblock *val, ) nogil void pykrb5_keyblock_get( krb5_keyblock *key, krb5_enctype *enctype, size_t *length, char **data, ) nogil krb5_error_code krb5_copy_keyblock( krb5_context context, const krb5_keyblock *from_, krb5_keyblock **to, ) nogil cdef class KeyBlock: # cdef Context ctx # cdef krb5_keyblock *raw # cdef int needs_free def __cinit__(KeyBlock self, Context context, needs_free=1): self.ctx = context self.raw = NULL self.needs_free = needs_free def __dealloc__(KeyBlock self): if self.raw != NULL and self.needs_free: krb5_free_keyblock(self.ctx.raw, self.raw) self.raw = NULL def __len__(KeyBlock self) -> int: cdef size_t length pykrb5_keyblock_get(self.raw, NULL, &length, NULL) return length def __repr__(KeyBlock self) -> str: kwargs = [f"{k}={v}" for k, v in { 'enctype': self.enctype, 'length': len(self), }.items()] return f"KeyBlock({', '.join(kwargs)})" def __str__(KeyBlock self) -> str: return f"KeyBlock {self.enctype}" @property def data(KeyBlock self) -> bytes: cdef size_t length cdef char *data pykrb5_keyblock_get(self.raw, NULL, &length, &data) if length == 0: return b"" else: return data[:length] @property def enctype(KeyBlock self) -> int: cdef krb5_enctype enctype pykrb5_keyblock_get(self.raw, &enctype, NULL, NULL) return enctype def init_keyblock( Context context not None, krb5_enctype enctype, const unsigned char[:] key, ) -> KeyBlock: kb = KeyBlock(context) cdef krb5_error_code err = 0 cdef size_t length = 0 cdef const char *key_ptr = NULL if key is not None and len(key): length = len(key) key_ptr = &key[0] err = krb5_init_keyblock_generic(context.raw, enctype, length, key_ptr, &kb.raw) if err: raise Krb5Error(context, err) return kb def copy_keyblock( Context context not None, KeyBlock keyblock not None, ) -> KeyBlock: out = KeyBlock(context) cdef krb5_error_code err = 0 err = krb5_copy_keyblock(context.raw, keyblock.raw, &out.raw) if err: raise Krb5Error(context, err) return out pykrb5-0.8.0/src/krb5/_keyblock_mit.pyi000066400000000000000000000016371505521762700177440ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import typing from krb5._context import Context from krb5._keyblock import KeyBlock def c_string_to_key( context: Context, enctype: int, string: bytes, salt: bytes, s2kparams: typing.Optional[bytes] = None, ) -> KeyBlock: """Convert a password string to a key. Convert a password string and a salt value plus optional S2K parameters to a keyblock with a certain encryption type. For getting the salt value, encryption type and the S2K parameters the method :meth:`get_etype_info` can be used. Args: context: Krb5 context. enctype: The encryption type to be used. string: The password string. salt: The salt string. s2kparams: The S2K parameters. Returns: KeyBlock: The keyblock. """ pykrb5-0.8.0/src/krb5/_keyblock_mit.pyx000066400000000000000000000037761505521762700177710ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._exceptions import Krb5Error from krb5._keyblock import init_keyblock from krb5._context cimport Context from krb5._keyblock cimport KeyBlock from krb5._krb5_types cimport * cdef extern from "python_krb5.h": krb5_error_code krb5_c_string_to_key( krb5_context context, krb5_enctype enctype, const krb5_data *string, const krb5_data *salt, krb5_keyblock *key, ) nogil krb5_error_code krb5_c_string_to_key_with_params( krb5_context context, krb5_enctype enctype, const krb5_data *string, const krb5_data *salt, const krb5_data *params, krb5_keyblock *key, ) nogil def c_string_to_key( Context context not None, krb5_enctype enctype, const unsigned char[:] string, const unsigned char[:] salt, const unsigned char[:] s2kparams = None, ) -> KeyBlock: cdef krb5_error_code err = 0 cdef size_t length = 0 cdef KeyBlock kb = init_keyblock(context, enctype, None) cdef krb5_data string_raw if len(string) == 0: pykrb5_set_krb5_data(&string_raw, 0, "") else: pykrb5_set_krb5_data(&string_raw, len(string), &string[0]) cdef krb5_data salt_raw if len(salt) == 0: pykrb5_set_krb5_data(&salt_raw, 0, "") else: pykrb5_set_krb5_data(&salt_raw, len(salt), &salt[0]) cdef krb5_data s2kparams_raw if s2kparams is None: err = krb5_c_string_to_key(context.raw, enctype, &string_raw, &salt_raw, kb.raw) else: if len(s2kparams) == 0: pykrb5_set_krb5_data(&s2kparams_raw, 0, "") else: pykrb5_set_krb5_data(&s2kparams_raw, len(s2kparams), &s2kparams[0]) err = krb5_c_string_to_key_with_params(context.raw, enctype, &string_raw, &salt_raw, &s2kparams_raw, kb.raw) if err: raise Krb5Error(context, err) return kb pykrb5-0.8.0/src/krb5/_krb5_types.pxd000066400000000000000000000075741505521762700173570ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from libc.stdint cimport int32_t, uint8_t, uint32_t cdef extern from "python_krb5.h": """ // The Heimdal and MIT krb5 libraries have different implementations of the krb5_data struct. // MIT uses a struct with a member magic of -1760647422L // Heimdal uses a struct without a magic void pykrb5_init_krb5_data( krb5_data *data ) { #if defined(HEIMDAL_XFREE) krb5_data_zero(data); #else data->magic = KV5M_DATA; data->length = 0; data->data = NULL; #endif } // The structures are different so cannot be explicitly defined in Cython. Use inline C to set the structs elements // by name. void pykrb5_set_krb5_data( krb5_data *data, size_t length, char *value ) { #if !defined(HEIMDAL_XFREE) data->magic = KV5M_DATA; #endif data->length = length; data->data = value; } void pykrb5_get_krb5_data( krb5_data *data, size_t *length, char **value ) { if (length) *length = data->length; if (value) *value = data->data; } void pykrb5_free_data_contents( krb5_context context, krb5_data *val ) { #if defined(HEIMDAL_XFREE) krb5_data_free(val); #else krb5_free_data_contents(context, val); #endif } """ ctypedef int32_t krb5_int32 ctypedef krb5_int32 krb5_error_code ctypedef krb5_int32 krb5_deltat ctypedef krb5_int32 krb5_enctype ctypedef uint8_t krb5_octet ctypedef krb5_int32 krb5_timestamp ctypedef unsigned int krb5_boolean ctypedef unsigned int krb5_kvno ctypedef void *krb5_pointer; ctypedef krb5_pointer krb5_cc_cursor ctypedef krb5_pointer krb5_kt_cursor; cdef struct _krb5_context: pass ctypedef _krb5_context *krb5_context cdef struct _krb5_cccol_cursor: pass ctypedef _krb5_cccol_cursor *krb5_cccol_cursor ctypedef struct krb5_principal_data: pass ctypedef krb5_principal_data *krb5_principal ctypedef const krb5_principal_data *krb5_const_principal cdef struct _krb5_ccache: pass ctypedef _krb5_ccache *krb5_ccache cdef struct _krb5_get_init_creds_opt: pass ctypedef _krb5_get_init_creds_opt krb5_get_init_creds_opt cdef struct _krb5_init_creds_context: pass ctypedef _krb5_init_creds_context *krb5_init_creds_context cdef struct _krb5_keyblock: pass ctypedef _krb5_keyblock krb5_keyblock cdef struct _krb5_data: pass ctypedef _krb5_data krb5_data cdef struct _krb5_kt: pass ctypedef _krb5_kt *krb5_keytab cdef struct krb5_keytab_entry_st: pass ctypedef krb5_keytab_entry_st krb5_keytab_entry cdef struct _krb5_creds: pass ctypedef _krb5_creds krb5_creds cdef struct _krb5_prompt: char *prompt int hidden krb5_data *reply ctypedef _krb5_prompt krb5_prompt cdef struct _pykrb5_ticket_times: krb5_timestamp authtime krb5_timestamp starttime krb5_timestamp endtime krb5_timestamp renew_till ctypedef _pykrb5_ticket_times pykrb5_ticket_times ctypedef krb5_error_code(*krb5_prompter_fct)( krb5_context context, void *data, const char *name, const char *banner, int num_prompts, krb5_prompt prompts[], ) void pykrb5_init_krb5_data( krb5_data *data, ) nogil void pykrb5_set_krb5_data( krb5_data *data, size_t length, char *value, ) nogil void pykrb5_get_krb5_data( krb5_data *data, size_t *length, char **value, ) nogil void pykrb5_free_data_contents( krb5_context context, krb5_data *val, ) nogil pykrb5-0.8.0/src/krb5/_kt.pxd000066400000000000000000000005671505521762700157010ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._context cimport Context from krb5._krb5_types cimport * cdef class KeyTab: cdef Context ctx cdef krb5_keytab raw cdef class KeyTabEntry: cdef Context ctx cdef krb5_keytab_entry raw cdef int needs_free pykrb5-0.8.0/src/krb5/_kt.pyi000066400000000000000000000140761505521762700157070ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import typing from krb5._context import Context from krb5._keyblock import KeyBlock from krb5._principal import Principal class KeyTab: """Kerberos KeyTab object. This class represents a Kerberos key table. Args: context: Krb5 context. """ def __iter__(self) -> typing.Iterator["KeyTabEntry"]: """Iterate through keytab entries. Enumerates through all the entries in a keytab. Will fail if the keytab being iterated does not exist. It may not be possible to add/remove entries on a keytab while it is being enumerated. """ @property def addr(self) -> typing.Optional[int]: """The raw krb5_keytab pointer address of this credential cache.""" @property def name(self) -> typing.Optional[bytes]: """The name/residual of the keytab.""" @property def kt_type(self) -> typing.Optional[bytes]: """The type of the keytab.""" class KeyTabEntry: """Kerberos KeyTabEntry object. This class represents a key table entry. Note: When using a key tab entry from enumerating a :class:`KeyTab`, the key and principal value is tied to the lifetime of the entry. Attempting to use either of these after the entry is out of scope and has been freed will crash the process. The principal can be copied with `copy(entry.principal)` to ensure it outlives the entry context. """ @property def key(self) -> KeyBlock: """The keytab key data block.""" @property def kvno(self) -> int: """The key version number associated with the keytab entry.""" @property def principal(self) -> Principal: """The principal associated with the keytab entry.""" @property def timestamp(self) -> int: """The time creation entry of the keytab entry.""" def kt_add_entry( context: Context, keytab: KeyTab, principal: Principal, kvno: int, timestamp: int, keyblock: KeyBlock, ) -> None: """Add new keytab entry. Adds a new entry to a key table. Args: context: Krb5 context. keytab: Key table to add the entry to. principal: The principal to add in the keytab. kvno: The key version number to add to the keytab. timestamp: The seconds since EPOCH when the entry was added. keyblock: The key and encryption type of the entry to add. """ def kt_default( context: Context, ) -> KeyTab: """Resolve the default key table. Get a handle to the default keytab. Args: context: Krb5 context. Returns: KeyTab: The default keytab. """ def kt_default_name( context: Context, ) -> bytes: """Get the default key table name. Gets the name of the default key table for the context specified. Args: context: Krb5 context. Returns: bytes: The default key table name. """ def kt_get_entry( context: Context, keytab: KeyTab, principal: Principal, kvno: int = 0, enctype: int = 0, ) -> KeyTabEntry: """Get an entry from a key table. Retrieve an entry from a key table which matches the keytab, principal, kvno, and enctype. If kvno is 0, retrieve the highest-numbered kvno matching the other fields. If enctype is 0, match any enctype. Args: context: Krb5 context. keytab: The keytab to search. principal: The principal to match. kvno: The kvno to match in the keytab or 0 to match the highest kvno. enctype: The encryption type to get in the keytab or 0 to match any. Returns: KeyTabEntry: The entry found in the keytab. """ def kt_get_name( context: Context, keytab: KeyTab, ) -> bytes: """Get a key table name. Get the name of the specified key table. See :meth:`kt_get_type()` to get the type of a keytab. Note: MIT Kerberos returns the full name whereas Heimdal just returns the name/residual. See :meth:`krb5_get_full_name` for the equivalent in Heimdal. Args: context: Krb5 context. keytab: The keytab to query. Returns: bytes: The name of the keytab. """ def kt_get_type( context: Context, keytab: KeyTab, ) -> bytes: """Get a key table type. Get the type of the specified key table. See :meth:`ky_get_name()` to get the name of a keytab. Args: context: Krb5 context. keytab: The keytab to query. Returns: bytes: The type of the keytab. """ def kt_read_service_key( context: Context, name: typing.Optional[bytes], principal: Principal, kvno: int = 0, enctype: int = 0, ) -> KeyBlock: """Retrieve a service key from a key table. Args: context: Krb5 context. name: The keytable to open with :meth:`kt_resolve`, uses :meth:`kt_default` if None or an empty byte string. principal: The service principal to select in the keytab. kvno: The key version number or 0 for the highest available. enctype: The encryption type or 0 for any type. Returns: KeyBlock: The key associated with the keytab entry. """ def kt_remove_entry( context: Context, keytab: KeyTab, entry: KeyTabEntry, ) -> None: """Remove keytab entry. Removes an entry from a key table. Args: context: Krb5 context. keytab: Key table to remove the entry from. entry: The entry to be removed. """ def kt_resolve( context: Context, name: bytes, ) -> KeyTab: """Get a handle for a key table. Resolve the key table name and open a handle. The name must be of the from ``type:residual`` where type must be known to the library. If no type is specified then ``FILE`` is used as a default. The ``residual`` value is dependent on the type specified. Args: context: Krb5 context. name: The name of the keytab in the form ``type:residual``. Returns: KeyTab: The opened keytab. """ pykrb5-0.8.0/src/krb5/_kt.pyx000066400000000000000000000352141505521762700157230ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import typing from libc.stdint cimport uint32_t, uintptr_t from libc.stdlib cimport free, malloc, realloc from libc.string cimport strlen from krb5._exceptions import Krb5Error from krb5._principal import PrincipalParseFlags from krb5._context cimport Context from krb5._keyblock cimport KeyBlock from krb5._krb5_types cimport * from krb5._principal cimport Principal cdef extern from "python_krb5.h": # Heimdal and MIT differ in their implementations """ // The funtions do the structure manipulations in the C code as it can reference the struct entries by name rather // than an explicitly defined offset in Cython which differ cross implementations. void pykrb5_keytab_entry_get( krb5_keytab_entry *entry, krb5_principal *principal, krb5_timestamp *timestamp, krb5_kvno *vno, krb5_keyblock **key ) { if (principal != NULL) *principal = entry->principal; if (timestamp != NULL) *timestamp = entry->timestamp; if (vno != NULL) *vno = entry->vno; #if defined(HEIMDAL_XFREE) if (key != NULL) *key = &entry->keyblock; #else if (key != NULL) *key = &entry->key; #endif } krb5_error_code krb5_kt_add_entry_generic( krb5_context context, krb5_keytab keytab, krb5_principal principal, krb5_kvno kvno, uint32_t timestamp, krb5_keyblock *key ) { krb5_keytab_entry entry; #if defined(HEIMDAL_XFREE) entry.principal = principal; entry.vno = kvno; entry.keyblock.keytype = key->keytype; entry.keyblock.keyvalue = key->keyvalue; entry.timestamp = timestamp; #else entry.magic = 0; entry.principal = principal; entry.timestamp = timestamp; entry.vno = kvno; entry.key.magic = key->magic; entry.key.enctype = key->enctype; entry.key.length = key->length; entry.key.contents = key->contents; #endif return krb5_kt_add_entry(context, keytab, &entry); } krb5_error_code krb5_kt_get_type_generic( krb5_context context, krb5_keytab keytab, char **prefix, size_t prefixsize ) { // MIT won't have this defined and our header sets it to -1 if it wasn't defined #if KRB5_KT_PREFIX_MAX_LEN == -1 *prefix = (char *)krb5_kt_get_type(context, keytab); return 0; #else return krb5_kt_get_type(context, keytab, *prefix, prefixsize); #endif } krb5_error_code krb5_kt_free_entry_generic( krb5_context context, krb5_keytab_entry *entry ) { // MIT has deprecated krb5_kt_free_entry in favour of this function #if defined(HEIMDAL_XFREE) return krb5_kt_free_entry(context, entry); #else return krb5_free_keytab_entry_contents(context, entry); #endif } """ krb5_error_code krb5_kt_add_entry_generic( krb5_context context, krb5_keytab keytab, krb5_principal principal, krb5_kvno kvno, uint32_t timestamp, krb5_keyblock *key, ) nogil krb5_error_code krb5_kt_close( krb5_context context, krb5_keytab keytab, ) nogil krb5_error_code krb5_kt_default( krb5_context context, krb5_keytab *id, ) nogil krb5_error_code krb5_kt_default_name( krb5_context context, char *name, int name_size, ) nogil krb5_error_code krb5_kt_end_seq_get( krb5_context context, krb5_keytab keytab, krb5_kt_cursor *cursor, ) nogil krb5_error_code krb5_kt_free_entry_generic( krb5_context context, krb5_keytab_entry *entry, ) nogil krb5_error_code krb5_kt_get_entry( krb5_context context, krb5_keytab keytab, krb5_const_principal principal, krb5_kvno vno, krb5_enctype enctype, krb5_keytab_entry *entry, ) nogil krb5_error_code krb5_kt_get_name( krb5_context context, krb5_keytab keytab, char *name, unsigned int namelen, ) nogil # See inline C code krb5_error_code krb5_kt_get_type_generic( krb5_context context, krb5_keytab keytab, char **prefix, size_t prefixsize, ) nogil krb5_error_code krb5_kt_next_entry( krb5_context context, krb5_keytab keytab, krb5_keytab_entry *entry, krb5_kt_cursor *cursor, ) nogil krb5_error_code krb5_kt_read_service_key( krb5_context context, krb5_pointer keyprocarg, krb5_principal principal, krb5_kvno vno, krb5_enctype enctype, krb5_keyblock **key, ) nogil krb5_error_code krb5_kt_remove_entry( krb5_context context, krb5_keytab id, krb5_keytab_entry *entry ) nogil krb5_error_code krb5_kt_resolve( krb5_context context, const char *name, krb5_keytab *ktid, ) nogil krb5_error_code krb5_kt_start_seq_get( krb5_context context, krb5_keytab keytab, krb5_kt_cursor *cursor, ) nogil void pykrb5_keytab_entry_get( krb5_keytab_entry *entry, krb5_principal *principal, krb5_timestamp *timestamp, krb5_kvno *vno, krb5_keyblock **key, ) nogil krb5_error_code KRB5_CONFIG_NOTENUFSPACE krb5_error_code KRB5_KT_END krb5_error_code KRB5_KT_NAME_TOOLONG krb5_error_code KRB5_KT_PREFIX_MAX_LEN cdef class KeyTab: # cdef Context ctx # cdef krb5_keytab raw def __cinit__(KeyTab self, Context context): self.ctx = context self.raw = NULL def __dealloc__(KeyTab self): if self.raw: krb5_kt_close(self.ctx.raw, self.raw) self.raw = NULL def __iter__(KeyTab self) -> typing.Iterator["KeyTabEntry"]: cdef krb5_error_code err = 0 cdef krb5_kt_cursor cursor err = krb5_kt_start_seq_get(self.ctx.raw, self.raw, &cursor) if err: raise Krb5Error(self.ctx, err) try: while True: entry = KeyTabEntry(self.ctx) err = krb5_kt_next_entry(self.ctx.raw, self.raw, &entry.raw, &cursor) if err == KRB5_KT_END: break elif err: raise Krb5Error(self.ctx, err) entry.needs_free = 1 yield entry finally: err = krb5_kt_end_seq_get(self.ctx.raw, self.raw, &cursor) if err: raise Krb5Error(self.ctx, err) @property def addr(self) -> typing.Optional[int]: if self.raw: return self.raw @property def name(KeyTab self) -> typing.Optional[bytes]: if self.raw: # MIT returns the type + name, this strips out the type to ensure # consistent behaviour across providers. name = kt_get_name(self.ctx, self) kt_type = self.kt_type if name.startswith(kt_type + b":"): name = name[len(kt_type) + 1:] return name @property def kt_type(KeyTab self) -> typing.Optional[bytes]: if self.raw: return kt_get_type(self.ctx, self) def __repr__(KeyTab self) -> str: if self.raw: kwargs = [f"{k}={v}" for k, v in { 'kt_type': self.kt_type.decode('utf-8'), 'name': self.name.decode('utf-8'), }.items()] return f"KeyTab({', '.join(kwargs)})" else: return "KeyTab(NULL)" def __str__(KeyTab self) -> str: if self.raw: return f"{self.kt_type.decode('utf-8')}:{self.name.decode('utf-8')}" else: return "NULL" cdef class KeyTabEntry: # cdef Context ctx # cdef krb5_keytab_entry raw # cdef int needs_free def __cinit__(KeyTabEntry self, Context context): self.ctx = context self.needs_free = 0 def __dealloc__(KeyTabEntry self): if self.needs_free: krb5_kt_free_entry_generic(self.ctx.raw, &self.raw) self.needs_free = 0 def __repr__(KeyTabEntry self) -> str: kwargs = [f"{k}={v}" for k, v in { 'principal': repr(self.principal), 'timestamp': self.timestamp, 'kvno': self.kvno, 'key': repr(self.key), }.items()] return f"KeyTabEntry({', '.join(kwargs)})" def __str__(KeyTabEntry self) -> str: return f"KVNO {self.kvno} {self.principal!s}" @property def key(KeyTabEntry self) -> KeyBlock: kb = KeyBlock(self.ctx, needs_free=0) pykrb5_keytab_entry_get(&self.raw, NULL, NULL, NULL, &kb.raw) return kb @property def kvno(KeyTabEntry self) -> int: cdef krb5_kvno kvno pykrb5_keytab_entry_get(&self.raw, NULL, NULL, &kvno, NULL) return kvno @property def principal(KeyTabEntry self) -> Principal: principal = Principal(self.ctx, PrincipalParseFlags.none, needs_free=0) pykrb5_keytab_entry_get(&self.raw, &principal.raw, NULL, NULL, NULL) return principal @property def timestamp(KeyTabEntry self) -> int: cdef krb5_timestamp timestamp pykrb5_keytab_entry_get(&self.raw, NULL, ×tamp, NULL, NULL) return timestamp def kt_add_entry( Context context not None, KeyTab keytab not None, Principal principal not None, krb5_kvno kvno, uint32_t timestamp, KeyBlock keyblock not None, ) -> None: cdef krb5_error_code err = 0 err = krb5_kt_add_entry_generic(context.raw, keytab.raw, principal.raw, kvno, timestamp, keyblock.raw) if err: raise Krb5Error(context, err) def kt_default( Context context not None, ) -> KeyTab: kt = KeyTab(context) cdef krb5_error_code err = 0 err = krb5_kt_default(context.raw, &kt.raw) if err: raise Krb5Error(context, err) return kt def kt_default_name( Context context not None, ) -> bytes: cdef krb5_error_code err = KRB5_CONFIG_NOTENUFSPACE buffer_size = 8192 buffer_length = buffer_size cdef char *buffer = malloc(buffer_length) if not buffer: raise MemoryError() try: while err == KRB5_CONFIG_NOTENUFSPACE: err = krb5_kt_default_name(context.raw, buffer, buffer_length) if err == KRB5_CONFIG_NOTENUFSPACE: buffer_length += buffer_size # Use a temp var to ensure buffer is always something valid to be freed new_buffer = realloc(buffer, buffer_length) if not new_buffer: raise MemoryError() buffer = new_buffer elif err: raise Krb5Error(context, err) else: name_len = strlen(buffer) return buffer[:name_len] finally: free(buffer) def kt_get_entry( Context context not None, KeyTab keytab not None, Principal principal not None, krb5_kvno kvno=0, krb5_enctype enctype=0, ) -> KeyTabEntry: cdef KeyTabEntry entry = KeyTabEntry(context) cdef krb5_error_code err = 0 err = krb5_kt_get_entry(context.raw, keytab.raw, principal.raw, kvno, enctype, &entry.raw) if err: raise Krb5Error(context, err) return entry def kt_get_name( Context context not None, KeyTab keytab not None, ) -> bytes: cdef krb5_error_code err = KRB5_KT_NAME_TOOLONG buffer_size = 8192 buffer_length = buffer_size cdef char *buffer = malloc(buffer_length) if not buffer: raise MemoryError() try: while err == KRB5_KT_NAME_TOOLONG: err = krb5_kt_get_name(context.raw, keytab.raw, buffer, buffer_length) # Heimdal does not define KRB5_KT_NAME_TOOLONG so fail on the first try. if err and (err != KRB5_KT_NAME_TOOLONG or KRB5_KT_NAME_TOOLONG == 1): raise Krb5Error(context, err) elif err == KRB5_KT_NAME_TOOLONG: buffer_length += buffer_size # Use a temp var to ensure buffer is always something valid to be freed new_buffer = realloc(buffer, buffer_length) if not new_buffer: raise MemoryError() buffer = new_buffer else: name_len = strlen(buffer) return buffer[:name_len] finally: free(buffer) def kt_get_type( Context context not None, KeyTab keytab not None, ) -> bytes: cdef krb5_error_code err = 0 cdef char *buffer = NULL if KRB5_KT_PREFIX_MAX_LEN == -1: # MIT Kerberos just returns a const char* which shouldn't be freed krb5_kt_get_type_generic(context.raw, keytab.raw, &buffer, 0) return buffer else: # Heimdal requires the caller to allocate and free the memory. Use the defined max len for the prefix. buffer_length = KRB5_KT_PREFIX_MAX_LEN buffer = malloc(buffer_length) if not buffer: raise MemoryError() try: err = krb5_kt_get_type_generic(context.raw, keytab.raw, &buffer, buffer_length) if err: raise Krb5Error(context, err) type_len = strlen(buffer) return buffer[:type_len] finally: free(buffer) def kt_read_service_key( Context context not None, const unsigned char[:] name, Principal principal not None, krb5_kvno kvno = 0, krb5_enctype enctype = 0, ) -> KeyBlock: kb = KeyBlock(context) cdef krb5_error_code err = 0 cdef krb5_pointer name_ptr = NULL if len(name): name_ptr = &name[0] else: raise ValueError("KeyTab must be set") err = krb5_kt_read_service_key(context.raw, name_ptr, principal.raw, kvno, enctype, &kb.raw) if err: raise Krb5Error(context, err) return kb def kt_remove_entry( Context context not None, KeyTab keytab not None, KeyTabEntry entry not None, ) -> None: cdef krb5_error_code err = 0 err = krb5_kt_remove_entry(context.raw, keytab.raw, &entry.raw) if err: raise Krb5Error(context, err) def kt_resolve( Context context not None, const unsigned char[:] name not None, ) -> KeyTab: kt = KeyTab(context) cdef krb5_error_code err = 0 cdef const char *name_ptr = NULL if len(name): name_ptr = &name[0] else: raise ValueError("KeyTab must be set") err = krb5_kt_resolve(context.raw, name_ptr, &kt.raw) if err: raise Krb5Error(context, err) return kt pykrb5-0.8.0/src/krb5/_kt_have_content.pyi000066400000000000000000000010571505521762700204370ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._context import Context from krb5._kt import KeyTab def kt_have_content( context: Context, keytab: KeyTab, ) -> bool: """Check if a keytab exists and contains entries. Checks if the keytab passed in exists and contains entries. Args: context: Krb5 context. keytab: They keytab to query. Returns: bool: Whether the keytab exists and contains entries. """ pykrb5-0.8.0/src/krb5/_kt_have_content.pyx000066400000000000000000000012121505521762700204470ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._exceptions import Krb5Error from krb5._context cimport Context from krb5._krb5_types cimport * from krb5._kt cimport KeyTab cdef extern from "python_krb5.h": # Added in MIT 1.11 krb5_error_code krb5_kt_have_content( krb5_context context, krb5_keytab keytab, ) nogil def kt_have_content( Context context not None, KeyTab keytab not None, ) -> bool: cdef krb5_error_code err = 0 err = krb5_kt_have_content(context.raw, keytab.raw) return err == 0 pykrb5-0.8.0/src/krb5/_kt_heimdal.pyi000066400000000000000000000010351505521762700173610ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._context import Context from krb5._kt import KeyTab def kt_get_full_name( context: Context, keytab: KeyTab, ) -> bytes: """Retrieve the full name of the keytab. Retrieves the full name of the keytab in the form ``type:residual``. Args: Context: Krb5 context. keytab: The keytab to query. Returns: bytes: The fullname of the keytab. """ pykrb5-0.8.0/src/krb5/_kt_heimdal.pyx000066400000000000000000000015741505521762700174100ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._exceptions import Krb5Error from krb5._context cimport Context from krb5._krb5_types cimport * from krb5._kt cimport KeyTab cdef extern from "python_krb5.h": krb5_error_code krb5_kt_get_full_name( krb5_context context, krb5_keytab keytab, char **str, ) nogil krb5_error_code krb5_xfree( void *ptr, ) nogil krb5_error_code KRB5_KT_PREFIX_MAX_LEN def kt_get_full_name( Context context not None, KeyTab keytab not None, ) -> bytes: cdef krb5_error_code err = 0 cdef char *str = NULL err = krb5_kt_get_full_name(context.raw, keytab.raw, &str) if err: raise Krb5Error(context, err) try: return str finally: krb5_xfree(str) pykrb5-0.8.0/src/krb5/_kt_mit.pyi000066400000000000000000000014611505521762700165520ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._context import Context from krb5._kt import KeyTab def kt_client_default( context: Context, ) -> KeyTab: """Resolve the default client key table. Get a handle to the default client key tab. Args: context: Krb5 context. Returns: KeyTab: The default client keytab. """ def kt_dup( context: Context, keytab: KeyTab, ) -> KeyTab: """Duplicate keytab handle. Duplicates the referenced keytab. The new handle can be closed independently to the referenced keytab. Args: context: Krb5 context. keytab: The keytab to duplicate. Returns: KeyTab: The duplicated keytab. """ pykrb5-0.8.0/src/krb5/_kt_mit.pyx000066400000000000000000000020731505521762700165710ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._exceptions import Krb5Error from krb5._context cimport Context from krb5._krb5_types cimport * from krb5._kt cimport KeyTab cdef extern from "python_krb5.h": krb5_error_code krb5_kt_client_default( krb5_context context, krb5_keytab *keytab_out, ) nogil krb5_error_code krb5_kt_dup( krb5_context context, krb5_keytab in_kt, krb5_keytab *out, ) nogil def kt_client_default( Context context not None, ) -> KeyTab: kt = KeyTab(context) cdef krb5_error_code err = 0 err = krb5_kt_client_default(context.raw, &kt.raw) if err: raise Krb5Error(context, err) return kt def kt_dup( Context context not None, KeyTab keytab not None, ) -> KeyTab: out_kt = KeyTab(context) cdef krb5_error_code err = 0 err = krb5_kt_dup(context.raw, keytab.raw, &out_kt.raw) if err: raise Krb5Error(context, err) return out_kt pykrb5-0.8.0/src/krb5/_principal.pxd000066400000000000000000000005111505521762700172310ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._context cimport Context from krb5._krb5_types cimport * cdef class Principal: cdef Context ctx cdef krb5_principal raw cdef int needs_free cdef int _parse_flags pykrb5-0.8.0/src/krb5/_principal.pyi000066400000000000000000000103311505521762700172400ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import enum import typing from krb5._context import Context class PrincipalParseFlags(enum.IntEnum): """Flags used to control :meth:`parse_name_flags`.""" none = ... #: No parse flags set no_realm = ... #: Error if realm is present require_realm = ... #: Error if realm is not present enterprise = ... #: Create single-component enterprise principal ignore_realm = ... #: Ignore realm if present class PrincipalUnparseFlags(enum.IntEnum): """Flags used to control :meth:`unparse_name_flags`.""" none = ... #: No unparse flags set short = ... #: Omit realm if it is the local realm no_realm = ... #: Omit realm always display = ... #: Don't escape special characters class NameType(enum.IntEnum): """A kerberos principal name type""" unknown = 0 #: Name type not known principal = 1 #: Just the name of the principal as in DCE, or for users srv_inst = 2 #: Service and other unique instance (krbtgt) srv_hst = 3 #: Service with host name as instance (telnet, rcommands) srv_xhst = 4 #: Service with host as remaining components uid = 5 #: Unique ID x500_principal = 6 #: Encoded X.509 Distinguished name [RFC2253] smtp_name = 7 #: Name in form of SMTP email name (e.g., user@example.com) enterprise_principal = 10 #: Enterprise name; may be mapped to principal name wellknown = 11 #: Well-known (special) principal ms_principal = -128 #: Windows 2000 UPN and SID ms_principal_and_id = -129 #: NT 4 style name ent_principal_and_id = -130 #: NT 4 style name and SID class Principal: """Kerberos Principal object. This class represents a Kerberos principal. Args: context: Krb5 context. """ def __copy__(self) -> "Principal": """Create a copy of the principal object.""" @property def addr(self) -> typing.Optional[int]: """The raw krb5_principal pointer address of this credential cache.""" @property def name(self) -> typing.Optional[bytes]: """The name of the principal.""" @property def realm(self) -> bytes: """The realm of the principal.""" @property def components(self) -> typing.List[bytes]: """The list of components of the principal.""" @property def type(self) -> NameType: """The name type of the principal.""" @type.setter def type(self, value: NameType) -> None: pass def copy_principal( context: Context, principal: Principal, ) -> Principal: """Copy a principal. Creates a copy of the principal specified. Args: context: Krb5 context. principal: The principal to copy. Returns: Principal: The copy of the principal. """ def parse_name_flags( context: Context, name: bytes, flags: typing.Union[int, PrincipalParseFlags] = PrincipalParseFlags.none, ) -> Principal: """Create a Kerberos principal. Convert a string principal name to a Kerberos principal object. Args: context: Krb5 context. name: The principal name to parse. flags: Optional flags to control how the string is parsed. Returns: Principal: The Kerberos principal parsed from the string. """ def unparse_name_flags( context: Context, principal: Principal, flags: typing.Union[int, PrincipalUnparseFlags] = PrincipalUnparseFlags.none, ) -> bytes: """Get the Kerberos principal name. Converts a Kerberos principal to a string representation. args: context: Krb5 context. principal: The principal to convert from. flags: Optional flags to control how the string is generated. Returns: bytes: The principal as a byte string. """ def build_principal( context: Context, realm: bytes, components: typing.Iterable[bytes], ) -> Principal: """Build a principal name. Create a Kerberos principal from a realm name and a list of components. args: context: Krb5 context. realm: The realm name. components: The list of components. Returns: bytes: The principal as a byte string. """ pykrb5-0.8.0/src/krb5/_principal.pyx000066400000000000000000000320371505521762700172660ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import enum import typing from cpython cimport array from libc.stdint cimport int32_t, uintptr_t from krb5._exceptions import Krb5Error from krb5._context cimport Context from krb5._krb5_types cimport * cdef extern from "python_krb5.h": # krb5_free_unparsed_name is deprecated in Heimdal - use krb5_xfree instead """ #if defined(HEIMDAL_XFREE) #include "krb5_asn1.h" #endif void krb5_free_unparsed_name_generic(krb5_context context, char *val) { #if defined(HEIMDAL_XFREE) krb5_xfree(val); #else krb5_free_unparsed_name(context, val); #endif } void pykrb5_principal_get( krb5_principal principal, size_t *realm_name_length, char **realm_name, size_t *component_count, int32_t *type ) { #if defined(HEIMDAL_XFREE) if (realm_name_length != NULL) *realm_name_length = strlen(principal->realm); if (realm_name != NULL) *realm_name = principal->realm; if (component_count != NULL) *component_count = principal->name.name_string.len; if (type != NULL) *type = principal->name.name_type; #else if (realm_name_length != NULL) *realm_name_length = principal->realm.length; if (realm_name != NULL) *realm_name = principal->realm.data; if (component_count != NULL) *component_count = principal->length; if (type != NULL) *type = principal->type; #endif } int pykrb5_principal_set( krb5_principal principal, size_t realm_name_length, const char *realm_name, size_t component_count ) { memset(principal, 0, sizeof(*principal)); #if defined(HEIMDAL_XFREE) principal->realm = (char *)realm_name; principal->name.name_type = 0; principal->name.name_string.len = component_count; principal->name.name_string.val = malloc(component_count * sizeof(krb5_data)); if (!principal->name.name_string.val) return 0; #else principal->realm.length = realm_name_length; principal->realm.data = (char *)realm_name; principal->length = component_count; principal->type = 0; principal->data = malloc(component_count * sizeof(krb5_data)); if (!principal->data) return 0; #endif return 1; } void pykrb5_principal_set_type( krb5_principal principal, int32_t type ) { #if defined(HEIMDAL_XFREE) principal->name.name_type = type; #else principal->type = type; #endif } void pykrb5_principal_get_component( krb5_principal principal, size_t pos, size_t *component_length, char **component ) { #if defined(HEIMDAL_XFREE) if (component_length != NULL) *component_length = strlen(principal->name.name_string.val[pos]); if (component != NULL) *component = principal->name.name_string.val[pos]; #else if (component_length != NULL) *component_length = principal->data[pos].length; if (component != NULL) *component = principal->data[pos].data; #endif } void pykrb5_principal_set_component( krb5_principal principal, size_t pos, size_t component_length, const char *component ) { #if defined(HEIMDAL_XFREE) principal->name.name_string.val[pos] = (char *)component; #else principal->data[pos].length = component_length; principal->data[pos].data = (char *)component; #endif } void pykrb5_principal_set_free( krb5_principal principal ) { #if defined(HEIMDAL_XFREE) free(principal->name.name_string.val); #else free(principal->data); #endif } """ krb5_error_code krb5_copy_principal( krb5_context context, krb5_const_principal inprinc, krb5_principal *outprinc, ) nogil void krb5_free_principal( krb5_context context, krb5_principal val, ) nogil # See inline C code void krb5_free_unparsed_name_generic( krb5_context context, char *val, ) nogil krb5_error_code krb5_parse_name_flags( krb5_context context, const char *name, int flags, krb5_principal *principal_out, ) nogil krb5_error_code krb5_unparse_name_flags( krb5_context context, krb5_const_principal principal, int flags, char **name, ) nogil int32_t KRB5_PRINCIPAL_PARSE_NO_REALM int32_t KRB5_PRINCIPAL_PARSE_REQUIRE_REALM int32_t KRB5_PRINCIPAL_PARSE_ENTERPRISE int32_t KRB5_PRINCIPAL_PARSE_IGNORE_REALM int32_t KRB5_PRINCIPAL_UNPARSE_SHORT int32_t KRB5_PRINCIPAL_UNPARSE_NO_REALM int32_t KRB5_PRINCIPAL_UNPARSE_DISPLAY void pykrb5_principal_get( krb5_principal principal, size_t *realm_name_length, const char **realm_name, size_t *component_count, int32_t *type ) nogil int pykrb5_principal_set( krb5_principal principal, size_t realm_name_length, const char *realm_name, size_t component_count, ) nogil void pykrb5_principal_set_type( krb5_principal principal, int32_t type ) nogil void pykrb5_principal_get_component( krb5_principal principal, size_t pos, size_t *component_length, const char **component ) nogil void pykrb5_principal_set_component( krb5_principal principal, size_t pos, size_t component_length, const char *component, ) void pykrb5_principal_set_free( krb5_principal principal, ) class PrincipalParseFlags(enum.IntEnum): none = 0 no_realm = KRB5_PRINCIPAL_PARSE_NO_REALM require_realm = KRB5_PRINCIPAL_PARSE_REQUIRE_REALM enterprise = KRB5_PRINCIPAL_PARSE_ENTERPRISE ignore_realm = KRB5_PRINCIPAL_PARSE_IGNORE_REALM class PrincipalUnparseFlags(enum.IntEnum): none = 0 short = KRB5_PRINCIPAL_UNPARSE_SHORT no_realm = KRB5_PRINCIPAL_UNPARSE_NO_REALM display = KRB5_PRINCIPAL_UNPARSE_DISPLAY class NameType(enum.IntEnum): # See also https://github.com/krb5/krb5-assignments/blob/master/name-type # https://www.rfc-editor.org/rfc/rfc4120.html#section-7.5.8 unknown = 0 principal = 1 srv_inst = 2 srv_hst = 3 srv_xhst = 4 uid = 5 x500_principal = 6 smtp_name = 7 enterprise_principal = 10 # https://www.rfc-editor.org/rfc/rfc6111.html#section-3.1 wellknown = 11 # Not standardized, supported by MIT and Heimdal ms_principal = -128 ms_principal_and_id = -129 ent_principal_and_id = -130 @classmethod def _missing_(cls, value: object) -> typing.Optional[enum.Enum]: if not isinstance(value, int): return None value = int(value) new_member = int.__new__(cls, value) new_member._name_ = f"Unknown_NameType_{str(value).replace('-', 'm')}" new_member._value_ = value return cls._value2member_map_.setdefault(value, new_member) cdef class Principal: """Kerberos Principal object. This class represents a Kerberos principal. Args: context: Krb5 context. """ # cdef Context ctx # cdef krb5_principal raw # cdef int needs_free # cdef int _parse_flags def __cinit__(Principal self, Context context, flags, int needs_free=1): self.ctx = context self.raw = NULL self.needs_free = needs_free self._parse_flags = flags def __copy__(Principal self): return copy_principal(self.ctx, self) def __dealloc__(Principal self): if self.raw and self.needs_free: krb5_free_principal(self.ctx.raw, self.raw) self.raw = NULL @property def addr(Principal self) -> typing.Optional[int]: if self.raw: return self.raw @property def name(Principal self) -> typing.Optional[bytes]: if self.raw: # Heimdal fails to unparse a no_realm principal if the no_realm unparse flags aren't used. flags = PrincipalUnparseFlags.none if ( self._parse_flags & PrincipalParseFlags.no_realm or self._parse_flags & PrincipalParseFlags.ignore_realm ): flags = PrincipalUnparseFlags.no_realm return unparse_name_flags(self.ctx, self, flags=flags) def __repr__(Principal self) -> str: name = self.name return f"Principal({name.decode('utf-8') if name else 'NULL'})" def __str__(Principal self) -> str: name = self.name return name.decode('utf-8') if name else 'NULL' @property def realm(Principal self) -> bytes: cdef size_t length cdef char *value if not self.raw: raise ValueError("Attempting to access property of NULL principal") pykrb5_principal_get(self.raw, &length, &value, NULL, NULL) if length == 0: return b"" else: return value[:length] @property def components(Principal self) -> typing.List[bytes]: cdef size_t component_count cdef size_t length cdef char *value if not self.raw: raise ValueError("Attempting to access property of NULL principal") pykrb5_principal_get(self.raw, NULL, NULL, &component_count, NULL) components = [] for pos in range(component_count): pykrb5_principal_get_component(self.raw, pos, &length, &value) if length == 0: component = b"" else: component = value[:length] components.append(component) return components @property def type(Principal self) -> NameType: cdef int32_t type if not self.raw: raise ValueError("Attempting to access property of NULL principal") pykrb5_principal_get(self.raw, NULL, NULL, NULL, &type) return NameType(type) @type.setter def type(Principal self, int32_t value): if not self.raw: raise ValueError("Attempting to access property of NULL principal") pykrb5_principal_set_type(self.raw, value) def copy_principal( Context context not None, Principal principal not None, ) -> Principal: out = Principal(context, principal._parse_flags) cdef krb5_error_code err = 0 err = krb5_copy_principal(context.raw, principal.raw, &out.raw) if err: raise Krb5Error(context, err) return out def parse_name_flags( Context context not None, const unsigned char[:] name not None, int flags=PrincipalParseFlags.none, ) -> Principal: principal = Principal(context, flags) cdef krb5_error_code err = 0 cdef const char *name_ptr = NULL if name is not None and len(name): name_ptr = &name[0] else: raise ValueError("Principal must be set") err = krb5_parse_name_flags(context.raw, name_ptr, flags, &principal.raw) if err: raise Krb5Error(context, err) return principal def unparse_name_flags( Context context not None, Principal principal not None, int flags=PrincipalUnparseFlags.none, ) -> bytes: cdef krb5_error_code err = 0 cdef char *name = NULL err = krb5_unparse_name_flags(context.raw, principal.raw, flags, &name) if err: raise Krb5Error(context, err) try: return name finally: krb5_free_unparsed_name_generic(context.raw, name) # Note: build_principal() does not actually call krb5_build_principal() because # this would require passing vararg parameters and because # krb5_build_principal() cannot handle NUL bytes in the strings. # Instead, the principal is built manually, and then duplicated with # copy_principal(). def build_principal( Context context not None, const unsigned char[:] realm not None, components: typing.Iterable[bytes], ) -> Principal: component_list = list(components) component_count = len(component_list) # Guess the component count, similar to the MIT implementation starting with 1.12 if component_count == 2 and component_list[0] == b'krbtgt': inferred_principal_type = NameType.srv_inst elif component_count >= 2 and component_list[0] == b'WELLKNOWN': inferred_principal_type = NameType.wellknown else: inferred_principal_type = NameType.principal cdef krb5_error_code err = 0 cdef krb5_principal_data raw if pykrb5_principal_set(&raw, len(realm), &realm[0], component_count) == 0: raise MemoryError() try: for pos in range(component_count): component = component_list[pos] pykrb5_principal_set_component(&raw, pos, len(component), component) out = Principal(context, 0) err = krb5_copy_principal(context.raw, &raw, &out.raw) if err: raise Krb5Error(context, err) out.type = inferred_principal_type return out finally: pykrb5_principal_set_free(&raw) pykrb5-0.8.0/src/krb5/_principal_heimdal.pyi000066400000000000000000000011021505521762700207170ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._context import Context from krb5._principal import Principal def principal_get_realm( context: Context, principal: Principal, ) -> bytes: """Get the realm of the principal. Gets the realm portion of the principal name passed in. Args: context: Krb5 context. principal: Krb5 principal to get the realm for. Returns: bytes: The realm portion of the principal specified. """ pykrb5-0.8.0/src/krb5/_principal_heimdal.pyx000066400000000000000000000010741505521762700207460ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._context cimport Context from krb5._krb5_types cimport * from krb5._principal cimport Principal cdef extern from "python_krb5.h": const char *krb5_principal_get_realm( krb5_context context, krb5_const_principal principal ) nogil def principal_get_realm( Context context not None, Principal principal not None, ) -> bytes: return krb5_principal_get_realm(context.raw, principal.raw) pykrb5-0.8.0/src/krb5/_set_password.pyi000066400000000000000000000110761505521762700200030ustar00rootroot00000000000000# Copyright: (c) 2024 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from __future__ import annotations import enum import typing from krb5._ccache import CCache from krb5._context import Context from krb5._creds import Creds from krb5._principal import Principal class SetPasswordResultCode(enum.IntEnum): """Password change result constants returned by :meth:`set_password()` Follow RFC 3244 with additional Microsoft extensions. """ SUCCESS = ... # Success MALFORMED = ... # Malformed request HARDERROR = ... # Server error AUTHERROR = ... # Authentication error SOFTERROR = ... # Password change rejected ACCESSDENIED = ... # Microsoft extension: Not authorized BAD_VERSION = ... # Microsoft extension: Unknown RPC version INITIAL_FLAG_NEEDED = ... # Microsoft extension: # The presented credentials were not obtained using a password directly class SetPasswordResult(typing.NamedTuple): """The result returned by :meth:`set_password()` and :meth:`set_password_using_ccache()`. The `result_code` and `result_code_string` are the pure library responses. See `SetPasswordResultCode` for more information. The `server_response` is a server protocol message that may contain useful information about password policy violations or other errors. Despite RFC 3244, the server response is not standardized and may vary. Depending on `kpasswd` implementation, it may be returned as:\n - 30-byte binary Active Directory Policy Information - UTF-8 byte string (MIT KDC, potentially Heimdal KDC) - raw bytes (unknown or custom implementation) The trick is that Active Directory Policy Information always starts with `0x0000` signature to distinguish from UTF-8. So the client may try decoding the server response with either :meth:`ADPolicyInfo.from_bytes()` or :meth:`bytes.decode()`. And if the decoding fails with corresponding `ValueError` or `UnicodeDecodeError`, the raw bytes should be analyzed. See `ADPolicyInfo` for more information. """ result_code: SetPasswordResultCode """The library result code of the password change operation.""" result_code_string: bytes """The byte string representation of the result code.""" server_response: bytes """Implementation-specific server response.""" def set_password( context: Context, creds: Creds, newpw: bytes, change_password_for: Principal | None = None, ) -> SetPasswordResult: """Set a password for a principal using specified credentials. This function implements the set password operation of ``RFC 3244``, for interoperability with Microsoft Windows implementations. It uses the credentials `creds` to set the password `newpw` for the principal `change_password_for`. If `change_password_for` is `None`, the password is set for the principal owning creds. If `change_password_for` is not `None`, the change is performed on the specified principal, assuming enough privileges. Note: the `creds` can be obtained using `get_init_creds_password()` with `in_tkt_service` set to ``kadmin/changepw``. Args: context: Krb5 context. creds: Credentials for kadmin/changepw service. newpw: New password. change_password_for: `None` or the principal to set the password for. Returns: SetPasswordResult: See `SetPasswordResult` for more information. """ def set_password_using_ccache( context: Context, ccache: CCache, newpw: bytes, change_password_for: Principal | None = None, ) -> SetPasswordResult: """Set a password for a principal using cached credentials. This function implements the set password operation of ``RFC 3244``, for interoperability with Microsoft Windows implementations. It uses the cached credentials from `ccache` to set the password `newpw` for the principal `change_password_for`. If `change_password_for` is `None`, the change is performed on the default principal in ccache. If `change_password_for` is not `None`, the change is performed on the specified principal. Note: the credentials can be obtained using `get_init_creds_password()` with `in_tkt_service` set to ``kadmin/changepw`` and stored to `ccache`. Args: context: Krb5 context. ccache: Credential cache. newpw: The new password. change_password_for: `None` or the principal to set the password for. Returns: SetPasswordResult: See `SetPasswordResult` for more information. """ pykrb5-0.8.0/src/krb5/_set_password.pyx000066400000000000000000000127511505521762700200230ustar00rootroot00000000000000# Support for Microsoft set/change password was added in MIT 1.7 import enum import typing from krb5._exceptions import Krb5Error from krb5._ccache cimport CCache from krb5._context cimport Context from krb5._creds cimport Creds from krb5._krb5_types cimport * from krb5._principal cimport Principal cdef extern from "python_krb5.h": int32_t KRB5_KPASSWD_SUCCESS int32_t KRB5_KPASSWD_MALFORMED int32_t KRB5_KPASSWD_HARDERROR int32_t KRB5_KPASSWD_AUTHERROR int32_t KRB5_KPASSWD_SOFTERROR int32_t KRB5_KPASSWD_ACCESSDENIED int32_t KRB5_KPASSWD_BAD_VERSION int32_t KRB5_KPASSWD_INITIAL_FLAG_NEEDED krb5_error_code krb5_set_password( krb5_context context, krb5_creds *creds, const char *newpw, krb5_principal change_password_for, int *result_code, krb5_data *result_code_string, krb5_data *result_string ) nogil krb5_error_code krb5_set_password_using_ccache( krb5_context context, krb5_ccache ccache, const char *newpw, krb5_principal change_password_for, int *result_code, krb5_data *result_code_string, krb5_data *result_string ) nogil class SetPasswordResultCode(enum.IntEnum): SUCCESS = KRB5_KPASSWD_SUCCESS MALFORMED = KRB5_KPASSWD_MALFORMED HARDERROR = KRB5_KPASSWD_HARDERROR AUTHERROR = KRB5_KPASSWD_AUTHERROR SOFTERROR = KRB5_KPASSWD_SOFTERROR ACCESSDENIED = KRB5_KPASSWD_ACCESSDENIED BAD_VERSION = KRB5_KPASSWD_BAD_VERSION INITIAL_FLAG_NEEDED = KRB5_KPASSWD_INITIAL_FLAG_NEEDED @classmethod def _missing_(cls, value: object) -> typing.Optional[enum.Enum]: if not isinstance(value, int): return None value = int(value) new_member = int.__new__(cls, value) new_member._name_ = f"Unknown_SetPasswordResultCode_{str(value).replace('-', 'm')}" new_member._value_ = value return cls._value2member_map_.setdefault(value, new_member) class SetPasswordResult(typing.NamedTuple): result_code: SetPasswordResultCode result_code_string: bytes server_response: bytes def set_password( Context context not None, Creds creds not None, const unsigned char[:] newpw not None, Principal change_password_for = None, ) -> SetPasswordResult: cdef krb5_error_code err = 0 cdef int result_code cdef krb5_data krb5_result_code_string cdef krb5_data krb5_server_response cdef char *newpw_ptr cdef krb5_principal change_password_for_ptr = NULL cdef size_t length cdef char *value if len(newpw) > 0: newpw_ptr = &newpw[0] else: newpw_ptr = b"" pykrb5_init_krb5_data(&krb5_result_code_string) pykrb5_init_krb5_data(&krb5_server_response) if change_password_for is not None: change_password_for_ptr = change_password_for.raw try: err = krb5_set_password( context.raw, creds.get_pointer(), newpw_ptr, change_password_for_ptr, &result_code, &krb5_result_code_string, &krb5_server_response ) if err: raise Krb5Error(context, err) pykrb5_get_krb5_data(&krb5_result_code_string, &length, &value) if length == 0: result_code_string = b"" else: result_code_string = value[:length] pykrb5_get_krb5_data(&krb5_server_response, &length, &value) if length == 0: server_response = b"" else: server_response = value[:length] return SetPasswordResult(result_code, result_code_string, server_response) finally: pykrb5_free_data_contents(context.raw, &krb5_result_code_string) pykrb5_free_data_contents(context.raw, &krb5_server_response) def set_password_using_ccache( Context context not None, CCache ccache not None, const unsigned char[:] newpw not None, Principal change_password_for = None, ) -> SetPasswordResult: cdef krb5_error_code err = 0 cdef int result_code cdef krb5_data krb5_result_code_string cdef krb5_data krb5_server_response cdef char *newpw_ptr cdef krb5_principal change_password_for_ptr = NULL cdef size_t length cdef char *value if len(newpw) > 0: newpw_ptr = &newpw[0] else: newpw_ptr = b"" pykrb5_init_krb5_data(&krb5_result_code_string) pykrb5_init_krb5_data(&krb5_server_response) if change_password_for is not None: change_password_for_ptr = change_password_for.raw try: err = krb5_set_password_using_ccache( context.raw, ccache.raw, newpw_ptr, change_password_for_ptr, &result_code, &krb5_result_code_string, &krb5_server_response ) if err: raise Krb5Error(context, err) pykrb5_get_krb5_data(&krb5_result_code_string, &length, &value) if length == 0: result_code_string = b"" else: result_code_string = value[:length] pykrb5_get_krb5_data(&krb5_server_response, &length, &value) if length == 0: server_response = b"" else: server_response = value[:length] return SetPasswordResult(result_code, result_code_string, server_response) finally: pykrb5_free_data_contents(context.raw, &krb5_result_code_string) pykrb5_free_data_contents(context.raw, &krb5_server_response) pykrb5-0.8.0/src/krb5/_string.pyi000066400000000000000000000021601505521762700165660ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from krb5._context import Context def enctype_to_string( context: Context, enctype: int, ) -> str: """Convert an encryption type to a string. Converts the encryption type identifier to the string name representation. Note: This API is marked as public but should not be called directly in MIT. Note: The Heimdal and MIT implementation return quite different values. It is recommended to use :meth:`enctype_to_name` if available on MIT to get a common value back. Args: context: Krb5 context. enctype: The encryption type identifier to convert. Returns: str: The encryption type name. """ def string_to_enctype( context: Context, string: str, ) -> int: """Convert string to encryption type. Converts a string to an encryption type integer. Args: context: Krb5 context. string: The string to convert from. Returns: int: The encryption type. """ pykrb5-0.8.0/src/krb5/_string.pyx000066400000000000000000000043721505521762700166140ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from libc.stdlib cimport free from krb5._exceptions import Krb5Error from krb5._context cimport Context from krb5._krb5_types cimport * cdef extern from "python_krb5.h": # Heimdal and MIT differ in their implementations """ krb5_error_code krb5_enctype_to_string_generic( krb5_context context, krb5_enctype enctype, char **buffer ) { // Heimdal takes in a context and sets an output pointer #if defined(HEIMDAL_XFREE) return krb5_enctype_to_string(context, enctype, buffer); #else char *tmp = malloc(100); if (tmp == NULL) { return ENOMEM; } *buffer = tmp; return krb5_enctype_to_string(enctype, tmp, 100); #endif } krb5_error_code krb5_string_to_enctype_generic( krb5_context context, char *string, krb5_enctype *enctypep ) { // MIT does not have a context overload #if defined(HEIMDAL_XFREE) return krb5_string_to_enctype(context, string, enctypep); #else return krb5_string_to_enctype(string, enctypep); #endif } """ krb5_error_code krb5_enctype_to_string_generic( krb5_context context, krb5_enctype enctype, char **buffer, ) nogil krb5_error_code krb5_string_to_enctype_generic( krb5_context context, char *string, krb5_enctype *enctypep, ) nogil def enctype_to_string( Context context not None, krb5_enctype enctype, ) -> str: cdef krb5_error_code err = 0 cdef char *buffer = NULL err = krb5_enctype_to_string_generic(context.raw, enctype, &buffer) if err: raise Krb5Error(context, err) try: return buffer.decode("utf-8") finally: free(buffer) def string_to_enctype( Context context not None, str string, ) -> int: cdef krb5_enctype enctype = 0 cdef krb5_error_code err = 0 b_string = string.encode("utf-8") cdef char *string_ptr = b_string err = krb5_string_to_enctype_generic(context.raw, string_ptr, &enctype) if err: raise Krb5Error(context, err) return enctype pykrb5-0.8.0/src/krb5/_string_mit.pyi000066400000000000000000000014131505521762700174370ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) def enctype_to_name( enctype: int, shortest: bool = False, ) -> str: """Convert an encryption type to a name or alias. Converts the encryption type identifier to either the full canonical name or the types shortest alias. Note: This API is marked as public but should not be called directly in MIT. Args: enctype: The encryption type identifier to convert. shortest: Return the shortest alias if `True` otherwise return the full canonical name. Returns: str: The encryption type name. Raises: ValueError: If the encryption type is invalid """ pykrb5-0.8.0/src/krb5/_string_mit.pyx000066400000000000000000000015701505521762700174620ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) from libc.stdlib cimport free, malloc from krb5._exceptions import Krb5Error from krb5._krb5_types cimport * cdef extern from "python_krb5.h": krb5_error_code krb5_enctype_to_name( krb5_enctype enctype, krb5_boolean shortest, char *buffer, size_t buflen, ) nogil def enctype_to_name( krb5_enctype enctype, krb5_boolean shortest = False, ) -> str: cdef krb5_error_code err = 0 cdef void *buffer = malloc(100) if buffer == NULL: raise MemoryError() err = krb5_enctype_to_name(enctype, shortest, buffer, 100) if err: raise ValueError("Invalid encryption type") try: return (buffer).decode("utf-8") finally: free(buffer) pykrb5-0.8.0/src/krb5/py.typed000066400000000000000000000000001505521762700160640ustar00rootroot00000000000000pykrb5-0.8.0/src/krb5/python_krb5.h000066400000000000000000000007071505521762700170200ustar00rootroot00000000000000#include "krb5.h" #if defined(HEIMDAL_XFREE) typedef krb5_times pykrb5_ticket_times; #else typedef krb5_ticket_times pykrb5_ticket_times; #endif // Heimdal does not define this #ifndef KRB5_KT_NAME_TOOLONG #define KRB5_KT_NAME_TOOLONG 1 #endif // MIT does not define this #ifndef KRB5_KT_PREFIX_MAX_LEN #define KRB5_KT_PREFIX_MAX_LEN -1 #endif // Heimdal does not define this #ifndef KRB5_TC_SUPPORTED_KTYPES #define KRB5_TC_SUPPORTED_KTYPES 0 #endif pykrb5-0.8.0/stubs/000077500000000000000000000000001505521762700141055ustar00rootroot00000000000000pykrb5-0.8.0/stubs/k5test/000077500000000000000000000000001505521762700153245ustar00rootroot00000000000000pykrb5-0.8.0/stubs/k5test/__init__.pyi000066400000000000000000000000541505521762700176050ustar00rootroot00000000000000from k5test.realm import K5Realm as K5Realm pykrb5-0.8.0/stubs/k5test/realm.pyi000066400000000000000000000060671505521762700171600ustar00rootroot00000000000000from typing import Any, Dict, List class K5Realm: def __new__(cls, *args: Any, **kwargs: Any) -> K5Realm: ... tmpdir: str is_existing: bool realm: str portbase: int user_princ: str admin_princ: str host_princ: str nfs_princ: str krbtgt_princ: str keytab: str client_keytab: str ccache: str kadmin_ccache: str env: Dict[str, str] def __init__( self, realm: str = ..., portbase: int = ..., krb5_conf: Dict[str, str] | None = ..., kdc_conf: Dict[str, str] | None = ..., create_kdb: bool = ..., krbtgt_keysalt: str | None = ..., create_user: bool = ..., get_creds: bool = ..., create_host: bool = ..., start_kdc: bool = ..., start_kadmind: bool = ..., existing: str | None = ..., **paths: str, ) -> None: ... @property def provider(self) -> str: ... def create_kdb(self) -> None: ... def addprinc( self, princname: str, password: str | None = ..., ) -> None: ... def change_password( self, principal: str, password: str | None = ..., keysalt: str | None = ..., ) -> None: ... def extract_keytab( self, princname: str, keytab: str, ) -> None: ... def kinit( self, princname: str, password: str | None = ..., flags: List[str] | None = ..., verbose: bool = ..., **keywords: Any, ) -> str: ... def klist( self, ccache: str | None = ..., **keywords: Any, ) -> str: ... def klist_keytab( self, keytab: str | None = ..., **keywords: Any, ) -> str: ... def prep_kadmin( self, princname: str | None = ..., pw: str | None = ..., flags: List[str] | None = ..., ) -> str: ... def run_kadmin( self, query: str | List[str], **keywords: Any, ) -> str: ... def run_kadminl( self, query: str | List[str], **keywords: Any, ) -> Any: ... def start_kdc( self, args: List[str] | None = ..., env: Dict[str, str] | None = ..., ) -> None: ... def start_kadmind( self, env: Dict[str, str] | None = ..., ) -> None: ... @property def hostname(self) -> str: ... def run( self, args: List[str], env: Dict[str, str] | None = ..., input: str | None = ..., expected_code: int = ..., ) -> str: ... def __del__(self) -> None: ... def kprop_port(self) -> int: ... def server_port(self) -> int: ... def stop_kdc(self) -> None: ... def stop_kadmind(self) -> None: ... def stop(self) -> None: ... def password( self, name: str, ) -> str: ... def special_env( self, name: str, has_kdc_conf: bool, krb5_conf: Dict[str, str] | None = ..., kdc_conf: Dict[str, str] | None = ..., ) -> Dict[str, str]: ... def kill_daemons(self) -> None: ... pykrb5-0.8.0/tests/000077500000000000000000000000001505521762700141075ustar00rootroot00000000000000pykrb5-0.8.0/tests/__init__.py000066400000000000000000000000001505521762700162060ustar00rootroot00000000000000pykrb5-0.8.0/tests/conftest.py000066400000000000000000000026261505521762700163140ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import os import typing import k5test import pytest import krb5 # This could be extensive to do per function so just do it once and share that @pytest.fixture(scope="session") def realm() -> typing.Iterator[k5test.K5Realm]: test_realm = k5test.K5Realm() try: original_env: typing.Dict[str, typing.Optional[str]] = {} for k in test_realm.env.keys(): original_env[k] = os.environ.pop(k, None) try: os.environ.update(test_realm.env) yield test_realm finally: for k, v in original_env.items(): if v: os.environ[k] = v else: del os.environ[k] finally: test_realm.stop() del test_realm @pytest.fixture(autouse=True) def requires_api(request: typing.Any) -> None: marker = request.node.get_closest_marker("requires_api") if marker: api_name = marker.args[0] if not hasattr(krb5, api_name): pytest.skip(f"KRB5 API {api_name} not available on current environment") return def pytest_configure(config: typing.Any) -> None: config.addinivalue_line( "markers", "requires_api(name): skip tests that don't have the required KRB5 API installed", ) pykrb5-0.8.0/tests/test_ccache.py000066400000000000000000000307071505521762700167350ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import os import os.path import pathlib import platform import sys import k5test import pytest import krb5 def test_cc_default(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() cc = krb5.cc_default(ctx) assert isinstance(cc, krb5.CCache) assert isinstance(cc.addr, int) assert cc.name == realm.ccache.encode() assert cc.cache_type == b"FILE" assert isinstance(cc.principal, krb5.Principal) assert str(cc.principal) == realm.user_princ assert repr(cc) == f"CCache(cache_type=FILE, name={realm.ccache})" assert str(cc) == f"FILE:{realm.ccache}" def test_cc_default_name(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() actual = krb5.cc_default_name(ctx) assert actual == realm.ccache.encode() def test_cc_destroy(tmpdir: pathlib.Path) -> None: ctx = krb5.init_context() cc = krb5.cc_resolve(ctx, f"FILE:{tmpdir / 'ccache'}".encode()) krb5.cc_initialize(ctx, cc, krb5.parse_name_flags(ctx, b"name@REALM")) assert os.path.isfile(tmpdir / "ccache") krb5.cc_destroy(ctx, cc) assert list(cc) == [] assert not os.path.exists(tmpdir / "ccache") assert repr(cc) == "CCache(NULL)" assert str(cc) == "NULL" assert cc.cache_type is None assert cc.name is None assert cc.principal is None def test_cc_get_name(tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() file_cc = krb5.cc_resolve(ctx, f"FILE:{tmp_path / 'ccache'}".encode()) assert krb5.cc_get_name(ctx, file_cc) == f"{tmp_path / 'ccache'}".encode() mem_cc = krb5.cc_new_unique(ctx, b"MEMORY") assert krb5.cc_get_name(ctx, mem_cc) == mem_cc.name def test_cc_get_principal() -> None: ctx = krb5.init_context() cc = krb5.cc_new_unique(ctx, b"MEMORY") krb5.cc_initialize(ctx, cc, krb5.parse_name_flags(ctx, b"name@REALM")) assert isinstance(cc.principal, krb5.Principal) assert str(cc.principal) == "name@REALM" def test_cc_get_type(tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() file_cc = krb5.cc_resolve(ctx, f"FILE:{tmp_path / 'ccache'}".encode()) assert krb5.cc_get_type(ctx, file_cc) == b"FILE" mem_cc = krb5.cc_new_unique(ctx, b"MEMORY") assert krb5.cc_get_type(ctx, mem_cc) == b"MEMORY" def test_cc_initialize(tmpdir: pathlib.Path) -> None: ctx = krb5.init_context() cc = krb5.cc_resolve(ctx, f"FILE:{tmpdir / 'ccache'}".encode()) assert not os.path.exists(tmpdir / "ccache") krb5.cc_initialize(ctx, cc, krb5.parse_name_flags(ctx, b"name@REALM")) assert os.path.isfile(tmpdir / "ccache") assert list(cc) == [] def test_cc_new_unique() -> None: ctx = krb5.init_context() cc = krb5.cc_new_unique(ctx, b"MEMORY") assert isinstance(cc, krb5.CCache) assert cc.cache_type == b"MEMORY" assert isinstance(cc.name, bytes) assert str(cc) == f"MEMORY:{cc.name.decode()}" assert repr(cc) == f"CCache(cache_type={cc.cache_type.decode()}, name={cc.name.decode()})" with pytest.raises(krb5.Krb5Error): cc.principal def test_cc_resolve(tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() cc = krb5.cc_resolve(ctx, f"FILE:{tmp_path / 'ccache'}".encode()) assert isinstance(cc, krb5.CCache) assert cc.cache_type == b"FILE" assert cc.name == f"{tmp_path / 'ccache'}".encode() assert str(cc) == f"FILE:{tmp_path / 'ccache'}" assert repr(cc) == f"CCache(cache_type=FILE, name={tmp_path / 'ccache'})" with pytest.raises(krb5.Krb5Error): cc.principal def test_cc_store_cred(realm: k5test.K5Realm, tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() princ = krb5.parse_name_flags(ctx, realm.user_princ.encode()) opt = krb5.get_init_creds_opt_alloc(ctx) creds = krb5.get_init_creds_password(ctx, princ, opt, realm.password("user").encode()) cc = krb5.cc_resolve(ctx, f"{tmp_path / 'ccache'}".encode()) krb5.cc_initialize(ctx, cc, princ) krb5.cc_store_cred(ctx, cc, creds) assert os.path.isfile(tmp_path / "ccache") assert len(list(cc)) > 0 @pytest.mark.requires_api("cc_dup") def test_cc_dup() -> None: ctx = krb5.init_context() cc = krb5.cc_new_unique(ctx, b"MEMORY") krb5.cc_initialize(ctx, cc, krb5.parse_name_flags(ctx, b"user@REALM")) cc_name = cc.name cc_addr = cc.addr copied_cc = krb5.cc_dup(ctx, cc) del cc assert isinstance(copied_cc, krb5.CCache) assert copied_cc.cache_type == b"MEMORY" assert copied_cc.name == cc_name assert str(copied_cc.principal) == "user@REALM" assert copied_cc.addr != cc_addr def test_cc_set_default_name() -> None: ctx = krb5.init_context() default_name = krb5.cc_default_name(ctx) princ = krb5.parse_name_flags(ctx, b"user@REALM") assert princ.name is not None cc = krb5.cc_new_unique(ctx, b"MEMORY") krb5.cc_set_default_name(ctx, b"MEMORY:" + (cc.name or b"")) assert krb5.cc_default_name(ctx) == b"MEMORY:" + (cc.name or b"") krb5.cc_initialize(ctx, cc, princ) actual_cc = krb5.cc_default(ctx) assert actual_cc.cache_type == b"MEMORY" assert actual_cc.name == cc.name assert actual_cc.principal is not None assert actual_cc.principal.name == princ.name krb5.cc_set_default_name(ctx, None) assert krb5.cc_default_name(ctx) == default_name def test_cc_switch(realm: k5test.K5Realm, tmp_path: pathlib.Path) -> None: # Heimdal has a bug where it thinks the sub collection ccache doesn't start with tkt (even when it does). I believe # this has been fixed but there are no releases of Heimdal that would contain this bugfix so we skip the test. # https://github.com/heimdal/heimdal/commit/7bf4d76e75e904dd65a0fbb90c9cad981245f714 if realm.provider.lower() == "heimdal": pytest.skip("Doesnt work on macOS (no DIR support) and current Heimdal releases have a bug") ctx = krb5.init_context() admin_princ = krb5.parse_name_flags(ctx, realm.admin_princ.encode()) user_princ = krb5.parse_name_flags(ctx, realm.user_princ.encode()) admin_ccache = krb5.cc_resolve(ctx, b"DIR:" + bytes(tmp_path)) krb5.cc_initialize(ctx, admin_ccache, admin_princ) user_ccache = krb5.cc_resolve(ctx, b"DIR::" + bytes(tmp_path / "tkt-user")) krb5.cc_initialize(ctx, user_ccache, user_princ) krb5.cc_switch(ctx, user_ccache) actual = krb5.cc_resolve(ctx, b"DIR:" + bytes(tmp_path)) assert actual.cache_type == b"DIR" assert actual.name == b":" + bytes(tmp_path / "tkt-user") assert actual.principal assert actual.principal.name == user_princ.name assert list(actual) == [] krb5.cc_switch(ctx, admin_ccache) actual = krb5.cc_resolve(ctx, b"DIR:" + bytes(tmp_path)) assert actual.cache_type == b"DIR" assert actual.name == b":" + bytes(tmp_path / "tkt") assert actual.principal assert actual.principal.name == admin_princ.name assert list(actual) == [] @pytest.mark.requires_api("cc_support_switch") def test_cc_supports_switch_invalid_type() -> None: with pytest.raises(ValueError, match="cache_type cannot be an empty byte string"): krb5.cc_support_switch(krb5.init_context(), b"") @pytest.mark.parametrize( "cache_type, expected", [ (b"FILE", False), # macOS doesn't support the DIR type so this returns False (b"DIR", False if sys.platform == "darwin" else True), ], ids=["FILE", "DIR"], ) @pytest.mark.requires_api("cc_support_switch") def test_cc_supports_switch(cache_type: bytes, expected: bool) -> None: actual = krb5.cc_support_switch(krb5.init_context(), cache_type) assert actual is expected @pytest.mark.requires_api("cc_cache_match") def test_cc_cache_match(realm: k5test.K5Realm, tmp_path: pathlib.Path, monkeypatch: pytest.MonkeyPatch) -> None: # Heimdal has a bug trying to iterate through a DIR collection ccache. This has been fixed on the master branch but # there are no releases that would contain this bugfix so we skip the test. # https://github.com/heimdal/heimdal/commit/7bf4d76e75e904dd65a0fbb90c9cad981245f714 if realm.provider.lower() == "heimdal": pytest.skip("Doesnt work on macOS (no DIR support) and current Heimdal releases have a bug") monkeypatch.setenv("KRB5CCNAME", "DIR:" + str(tmp_path)) ctx = krb5.init_context() admin_princ = krb5.parse_name_flags(ctx, realm.admin_princ.encode()) user_princ = krb5.parse_name_flags(ctx, realm.user_princ.encode()) opt = krb5.get_init_creds_opt_alloc(ctx) admin_ccache = krb5.cc_default(ctx) krb5.cc_initialize(ctx, admin_ccache, admin_princ) admin_creds = krb5.get_init_creds_password(ctx, admin_princ, opt, realm.password("admin").encode()) krb5.cc_store_cred(ctx, admin_ccache, admin_creds) user_ccache = krb5.cc_resolve(ctx, b"DIR::" + bytes(tmp_path) + b"/tkt-user") krb5.cc_initialize(ctx, user_ccache, user_princ) user_creds = krb5.get_init_creds_password(ctx, user_princ, opt, realm.password("user").encode()) krb5.cc_store_cred(ctx, user_ccache, user_creds) admin_actual = krb5.cc_cache_match(ctx, admin_princ) assert admin_actual.cache_type == b"DIR" assert admin_actual.name == b":" + bytes(tmp_path) + b"/tkt" assert admin_actual.principal assert admin_actual.principal.name == admin_princ.name user_actual = krb5.cc_cache_match(ctx, user_princ) assert user_actual.cache_type == b"DIR" assert user_actual.name == b":" + bytes(tmp_path) + b"/tkt-user" assert user_actual.principal assert user_actual.principal.name == user_princ.name def test_cc_config(realm: k5test.K5Realm, tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() princ = krb5.parse_name_flags(ctx, realm.user_princ.encode()) cc = krb5.cc_resolve(ctx, f"{tmp_path / 'ccache'}".encode()) krb5.cc_initialize(ctx, cc, princ) princ2 = krb5.parse_name_flags(ctx, b"other_principal") key1 = b"ConfigKey1" key2 = b"SecondConfigKey" msg_pattern = "Matching credential not found|End of credential cache reached|Did not find credential for" with pytest.raises(krb5.Krb5Error, match=msg_pattern): c = krb5.cc_get_config(ctx, cc, None, key1) with pytest.raises(krb5.Krb5Error, match=msg_pattern): c = krb5.cc_get_config(ctx, cc, None, key2) with pytest.raises(krb5.Krb5Error, match=msg_pattern): c = krb5.cc_get_config(ctx, cc, princ2, key1) with pytest.raises(krb5.Krb5Error, match=msg_pattern): c = krb5.cc_get_config(ctx, cc, princ2, key2) krb5.cc_set_config(ctx, cc, None, key1, b"Value1") krb5.cc_set_config(ctx, cc, princ2, key2, b"Value2") value1 = krb5.cc_get_config(ctx, cc, None, key1) assert value1 == b"Value1" with pytest.raises(krb5.Krb5Error, match=msg_pattern): c = krb5.cc_get_config(ctx, cc, None, key2) with pytest.raises(krb5.Krb5Error, match=msg_pattern): c = krb5.cc_get_config(ctx, cc, princ2, key1) value2 = krb5.cc_get_config(ctx, cc, princ2, key2) assert value2 == b"Value2" def test_cc_retrieve_remove_cred(realm: k5test.K5Realm, tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() princ = krb5.parse_name_flags(ctx, realm.user_princ.encode()) opt = krb5.get_init_creds_opt_alloc(ctx) creds = krb5.get_init_creds_password(ctx, princ, opt, realm.password("user").encode()) cc = krb5.cc_resolve(ctx, f"{tmp_path / 'ccache'}".encode()) krb5.cc_initialize(ctx, cc, princ) msg_pattern = "Matching credential not found|End of credential cache reached|Did not find credential for" with pytest.raises(krb5.Krb5Error, match=msg_pattern): c = krb5.cc_retrieve_cred(ctx, cc, krb5.CredentialsRetrieveFlags.match_srv_nameonly, creds) assert len(list(cc)) == 0 krb5.cc_store_cred(ctx, cc, creds) assert len(list(cc)) > 0 krb5.cc_retrieve_cred(ctx, cc, krb5.CredentialsRetrieveFlags.match_srv_nameonly, creds) if (realm.provider.lower() == "heimdal" and platform.system() == "Linux") or os.environ.get( "DEBIAN_VERSION", None ) == "10": # Removing credentials does not seem to have an effect with heimdal on Linux # Debian 10's version of krb5 MIT does not support remove_cred on the FILE ccache. return krb5.cc_remove_cred(ctx, cc, krb5.CredentialsRetrieveFlags.match_srv_nameonly, creds) msg_pattern = "Matching credential not found|End of credential cache reached|Did not find credential for" with pytest.raises(krb5.Krb5Error, match=msg_pattern): krb5.cc_retrieve_cred(ctx, cc, krb5.CredentialsRetrieveFlags.match_srv_nameonly, creds) pykrb5-0.8.0/tests/test_cccol.py000066400000000000000000000020221505521762700165770ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import krb5 def test_cccol_iter() -> None: ctx = krb5.init_context() ccache = krb5.cc_new_unique(ctx, b"MEMORY") krb5.cc_initialize(ctx, ccache, krb5.parse_name_flags(ctx, b"username@DOMAIN.COM")) assert ccache.principal is not None krb5.cc_set_default_name(ctx, (ccache.cache_type or b"") + b":" + (ccache.name or b"")) # MIT and Heimdal differ in the amounts returns, just make sure at least the MEMORY one is there actual = list(krb5.cccol_iter(ctx)) assert len(actual) > 0 for cache in actual: assert isinstance(cache, krb5.CCache) mem_ccache = next(iter([c for c in actual if c.cache_type == b"MEMORY"])) assert isinstance(mem_ccache, krb5.CCache) assert mem_ccache.cache_type == b"MEMORY" assert mem_ccache.name == ccache.name assert mem_ccache.principal is not None assert mem_ccache.principal.name == ccache.principal.name pykrb5-0.8.0/tests/test_changepw.py000066400000000000000000000216021505521762700173150ustar00rootroot00000000000000import locale import k5test import pytest import krb5 @pytest.mark.requires_api("chpw_message") def test_chpw_message() -> None: # MIT Kerberos test samples, https://github.com/krb5/krb5, human readable adpi_tests = { "complex": [ ( b"\0\0", b"\0\0\0\0", b"\0\0\0\0", b"\0\0\0\1", b"\0\0\0\0\0\0\0\0", b"\0\0\0\0\0\0\0\0", ), ( "The password must include numbers or symbols.", "Don't include any part of your name in the password.", ), ], "length": [ ( b"\0\0", b"\0\0\0\x0d", b"\0\0\0\0", b"\0\0\0\0", b"\0\0\0\0\0\0\0\0", b"\0\0\0\0\0\0\0\0", ), ("The password must contain at least 13 characters.",), ], "history": [ ( b"\0\0", b"\0\0\0\0", b"\0\0\0\x09", b"\0\0\0\0", b"\0\0\0\0\0\0\0\0", b"\0\0\0\0\0\0\0\0", ), ("The password must be different from the previous 9 passwords."), ], "age": [ ( b"\0\0", b"\0\0\0\0", b"\0\0\0\0", b"\0\0\0\0", b"\0\0\0\0\0\0\0\0", b"\0\0\x01\x92\x54\xd3\x80\0", ), ("The password can only be changed every 2 days."), ], "combined": [ ( b"\0\0", b"\0\0\0\x05", b"\0\0\0\x0d", b"\0\0\0\x01", b"\0\0\0\0\0\0\0\0", b"\0\0\0\xc9\x2a\x69\xc0\0", ), ( "The password can only be changed once a day.", "The password must be different from the previous 13 passwords.", "The password must contain at least 5 characters.", "The password must include numbers or symbols.", "Don't include any part of your name in the password.", ), ], "unknown": [ ( b"\0\0", b"\0\0\0\0", b"\0\0\0\0", b"\x80\0\0\1", b"\0\0\0\0\0\0\0\0", b"\0\0\0\0\0\0\0\0", ) ], } locale.setlocale(locale.LC_ALL, "C") ctx = krb5.init_context() samples = {k: b"".join(v[0]) if isinstance(v, list) else b"" for k, v in adpi_tests.items()} for k, test in adpi_tests.items(): if isinstance(test, list) and len(test) > 1: phrases = test[1] for phrase in phrases: message = krb5.chpw_message(ctx, samples[k]) assert message.decode().find(phrase) >= 0 assert krb5.ADPolicyInfoProp.COMPLEX in krb5.ADPolicyInfo.from_bytes(samples["complex"]).properties assert krb5.ADPolicyInfo.from_bytes(samples["length"]).min_length == 13 assert krb5.ADPolicyInfo.from_bytes(samples["history"]).history == 9 assert krb5.ADPolicyInfo.from_bytes(samples["age"]).min_age == 2 * 86400 * 10_000_000 assert krb5.ADPolicyInfo.from_bytes(samples["combined"]).min_length == 5 assert krb5.ADPolicyInfo.from_bytes(samples["combined"]).history == 13 assert krb5.ADPolicyInfo.from_bytes(samples["combined"]).min_age == 1 * 86400 * 10_000_000 assert krb5.ADPolicyInfoProp.COMPLEX in krb5.ADPolicyInfo.from_bytes(samples["combined"]).properties assert 0x80000000 & krb5.ADPolicyInfo.from_bytes(samples["unknown"]).properties != 0 def test_set_password(realm: k5test.K5Realm) -> None: if realm.provider != "mit": # Heimdal testing requires complicated kadmind and kpasswdd setup return realm.start_kadmind() princ_name = "exp@" + realm.realm old_password = realm.password("userexp") weak_password = "sh0rt" empty_password = "" new_password = realm.password("user") new_password2 = realm.password("user~") # setup realm.run_kadminl(["addpol", "-minlength", "6", "-minclasses", "2", "pwpol"]) realm.run_kadminl(["addprinc", "-pw", old_password, "-policy", "pwpol", "+needchange", princ_name]) ctx = krb5.init_context() princ = krb5.parse_name_flags(ctx, princ_name.encode()) admin_princ = krb5.parse_name_flags(ctx, realm.admin_princ.encode()) opt = krb5.get_init_creds_opt_alloc(ctx) # admin creds; will be reused with ccache as well admin_creds = krb5.get_init_creds_password( ctx, admin_princ, opt, realm.password("admin").encode(), in_tkt_service=b"kadmin/changepw" ) assert isinstance(admin_creds, krb5.Creds) # set_password for creds owner (self) with pytest.raises(krb5.Krb5Error) as exc: krb5.get_init_creds_password(ctx, princ, opt, password=old_password.encode()) assert exc.value.err_code == -1765328361 # KRB5KDC_ERR_KEY_EXP creds = krb5.get_init_creds_password(ctx, princ, opt, old_password.encode(), in_tkt_service=b"kadmin/changepw") assert isinstance(creds, krb5.Creds) (result_code, result_code_string, server_response) = krb5.set_password(ctx, creds, empty_password.encode()) assert result_code == krb5.SetPasswordResultCode.SOFTERROR assert result_code_string.find(b"rejected") > 0 assert server_response.find(b"too short") > 0 (result_code, result_code_string, server_response) = krb5.set_password(ctx, creds, weak_password.encode()) assert result_code == krb5.SetPasswordResultCode.SOFTERROR assert result_code_string.find(b"rejected") > 0 assert server_response.find(b"too short") > 0 (result_code, result_code_string, server_response) = krb5.set_password(ctx, creds, new_password.encode()) assert result_code == krb5.SetPasswordResultCode.SUCCESS creds = krb5.get_init_creds_password(ctx, princ, opt, new_password.encode()) assert isinstance(creds, krb5.Creds) assert creds.client.name == princ.name # set_password for other principal using admin creds (result_code, result_code_string, server_response) = krb5.set_password( ctx, admin_creds, new_password2.encode(), change_password_for=princ ) assert result_code == krb5.SetPasswordResultCode.SUCCESS creds = krb5.get_init_creds_password(ctx, princ, opt, new_password2.encode()) assert isinstance(creds, krb5.Creds) assert creds.client.name == princ.name # reset password locally for next test realm.run_kadminl(["cpw", "-pw", old_password, princ_name]) realm.run_kadminl(["modprinc", "+needchange", princ_name]) # set_password_using_ccache with pytest.raises(krb5.Krb5Error) as exc: krb5.get_init_creds_password(ctx, princ, opt, password=old_password.encode()) assert exc.value.err_code == -1765328361 # KRB5KDC_ERR_KEY_EXP creds = krb5.get_init_creds_password(ctx, princ, opt, old_password.encode(), in_tkt_service=b"kadmin/changepw") assert isinstance(creds, krb5.Creds) assert creds.client.name == princ.name cc = krb5.cc_new_unique(ctx, b"MEMORY") krb5.cc_initialize(ctx, cc, princ) krb5.cc_store_cred(ctx, cc, creds) (result_code, result_code_string, server_response) = krb5.set_password_using_ccache( ctx, cc, empty_password.encode(), princ ) assert result_code == krb5.SetPasswordResultCode.SOFTERROR assert result_code_string.find(b"rejected") > 0 assert server_response.find(b"too short") > 0 (result_code, result_code_string, server_response) = krb5.set_password_using_ccache( ctx, cc, weak_password.encode(), princ ) assert result_code == krb5.SetPasswordResultCode.SOFTERROR assert result_code_string.find(b"rejected") > 0 assert server_response.find(b"too short") > 0 (result_code, result_code_string, server_response) = krb5.set_password_using_ccache( ctx, cc, new_password.encode(), princ ) assert result_code == krb5.SetPasswordResultCode.SUCCESS creds = krb5.get_init_creds_password(ctx, princ, opt, new_password.encode()) assert isinstance(creds, krb5.Creds) assert creds.client.name == princ.name krb5.cc_destroy(ctx, cc) admin_cc = krb5.cc_new_unique(ctx, b"MEMORY") krb5.cc_initialize(ctx, admin_cc, admin_princ) krb5.cc_store_cred(ctx, admin_cc, admin_creds) # set_password for other principal using admin ccache (result_code, result_code_string, server_response) = krb5.set_password_using_ccache( ctx, admin_cc, new_password2.encode(), change_password_for=princ ) assert result_code == krb5.SetPasswordResultCode.SUCCESS creds = krb5.get_init_creds_password(ctx, princ, opt, new_password2.encode()) assert isinstance(creds, krb5.Creds) assert creds.client.name == princ.name realm.run_kadminl(["delprinc", "-force", princ_name]) realm.run_kadminl(["delpol", "-force", "pwpol"]) krb5.cc_destroy(ctx, admin_cc) realm.stop_kadmind() pykrb5-0.8.0/tests/test_context.py000066400000000000000000000041071505521762700172060ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import os import time import k5test import pytest import krb5 def test_init_context() -> None: context = krb5.init_context() assert context is not None assert isinstance(context, krb5.Context) assert str(context) == "Krb5Context" def test_set_default_realm(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() default = krb5.get_default_realm(ctx) assert default == realm.realm.encode() krb5.set_default_realm(ctx, b"NEW.REALM") default = krb5.get_default_realm(ctx) assert default == b"NEW.REALM" krb5.set_default_realm(ctx, None) default = krb5.get_default_realm(ctx) assert default == realm.realm.encode() def test_set_real_time() -> None: ctx = krb5.init_context() diff = krb5.timeofday(ctx) - time.time() assert diff > -5 assert diff < 5 now = krb5.us_timeofday(ctx) diff = now[0] * 1000000 + now[1] - int(time.time() * 1e6) assert diff > -5000000 assert diff < 5000000 krb5.set_real_time(ctx, int(time.time()) + 100, 0) diff = krb5.timeofday(ctx) - time.time() assert diff > 95 assert diff < 105 krb5.set_real_time(ctx, int(time.time()), -1) diff = krb5.timeofday(ctx) - time.time() assert diff > -5 assert diff < 5 @pytest.mark.requires_api("get_time_offsets") def test_get_time_offsets() -> None: ctx = krb5.init_context() sec, usec = krb5.get_time_offsets(ctx) assert sec == 0 assert usec == 0 krb5.set_real_time(ctx, int(time.time()) + 100, 0) sec, usec = krb5.get_time_offsets(ctx) assert sec > 95 assert sec < 105 krb5.set_real_time(ctx, int(time.time()), -1) sec, usec = krb5.get_time_offsets(ctx) assert sec > -5 assert sec < 5 @pytest.mark.requires_api("init_secure_context") def test_init_secure_context() -> None: context = krb5.init_secure_context() assert context is not None assert isinstance(context, krb5.Context) assert str(context) == "Krb5Context" pykrb5-0.8.0/tests/test_creds.py000066400000000000000000000303311505521762700166200ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import pathlib import time import typing import k5test import pytest import krb5 class MockPrompt(krb5.Krb5Prompt): def __init__(self, responses: typing.List[bytes]) -> None: self.init_calls: typing.List[typing.Tuple[typing.Optional[bytes], typing.Optional[bytes], int]] = [] self.prompt_calls: typing.List[typing.Tuple[bytes, bool]] = [] self._responses = responses def init( self, name: typing.Optional[bytes], banner: typing.Optional[bytes], num_prompts: int, ) -> None: self.init_calls.append((name, banner, num_prompts)) def prompt(self, msg: bytes, hidden: bool) -> bytes: self.prompt_calls.append((msg, hidden)) return self._responses.pop(0) def test_TicketFlags() -> None: # proxy (1 << 4) and two unknown flags (1 << 24 and 1 << 31) set flags = krb5.TicketFlags(0x81000010) assert krb5.TicketFlags.proxy in flags assert krb5.TicketFlags.forwarded not in flags # Clear proxy and forwarded, leave unknown flags intact flags = flags & ~(krb5.TicketFlags.proxy | krb5.TicketFlags.forwarded) assert krb5.TicketFlags.proxy not in flags assert krb5.TicketFlags.forwarded not in flags assert flags == 0x81000000 assert type(flags) == krb5.TicketFlags flags = flags | krb5.TicketFlags.postdated assert krb5.TicketFlags.postdated in flags assert flags == 0x81000040 assert type(flags) == krb5.TicketFlags def test_get_init_creds_keytab(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() princ = krb5.parse_name_flags(ctx, realm.host_princ.encode()) opt = krb5.get_init_creds_opt_alloc(ctx) kt = krb5.kt_default(ctx) creds = krb5.get_init_creds_keytab(ctx, princ, opt, kt) assert isinstance(creds, krb5.Creds) assert str(creds) == "Creds" assert creds.client.name == realm.host_princ.encode() assert creds.server.name == b"krbtgt/KRBTEST.COM@KRBTEST.COM" assert len(creds.keyblock.data) > 0 assert str(creds.times).startswith("TicketTimes(authtime=") assert krb5.TicketFlags.initial in creds.ticket_flags # creds.addresses assert len(creds.ticket) > 0 assert creds.second_ticket == b"" # creds.authdata def test_get_init_creds_password(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() princ = krb5.parse_name_flags(ctx, realm.user_princ.encode()) opt = krb5.get_init_creds_opt_alloc(ctx) creds = krb5.get_init_creds_password(ctx, princ, opt, realm.password("user").encode()) assert isinstance(creds, krb5.Creds) assert str(creds) == "Creds" def test_get_init_creds_password_prompt(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() princ = krb5.parse_name_flags(ctx, realm.user_princ.encode()) opt = krb5.get_init_creds_opt_alloc(ctx) prompter = MockPrompt([realm.password("user").encode()]) creds = krb5.get_init_creds_password(ctx, princ, opt, prompter=prompter) assert isinstance(creds, krb5.Creds) assert str(creds) == "Creds" assert len(prompter.init_calls) == 1 assert prompter.init_calls[0] == (None, None, 1) assert len(prompter.prompt_calls) == 1 expected = ( f"Password for {realm.user_princ}" if realm.provider == "mit" else f"{realm.user_princ}'s Password: " ).encode() assert prompter.prompt_calls[0] == (expected, True) def test_get_init_creds_password_prompt_failure(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() princ = krb5.parse_name_flags(ctx, realm.user_princ.encode()) opt = krb5.get_init_creds_opt_alloc(ctx) prompter = MockPrompt([]) with pytest.raises(krb5.Krb5Error): krb5.get_init_creds_password(ctx, princ, opt, prompter=prompter) assert len(prompter.init_calls) == 1 assert prompter.init_calls[0] == (None, None, 1) assert len(prompter.prompt_calls) == 1 def test_get_creds_keytab(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() princ = krb5.parse_name_flags(ctx, realm.host_princ.encode()) creds_ctx = krb5.init_creds_init(ctx, princ) assert isinstance(creds_ctx, krb5.InitCredsContext) assert str(creds_ctx) == "InitCredsContext" kt = krb5.kt_resolve(ctx, realm.keytab.encode()) krb5.init_creds_set_keytab(ctx, creds_ctx, kt) krb5.init_creds_get(ctx, creds_ctx) creds = krb5.init_creds_get_creds(ctx, creds_ctx) assert isinstance(creds, krb5.Creds) assert str(creds) == "Creds" def test_get_creds_keytab_wrong_principal(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() princ = krb5.parse_name_flags(ctx, realm.user_princ.encode()) creds_ctx = krb5.init_creds_init(ctx, princ) assert isinstance(creds_ctx, krb5.InitCredsContext) assert str(creds_ctx) == "InitCredsContext" kt = krb5.kt_resolve(ctx, realm.keytab.encode()) expected = "no suitable keys for" if realm.provider == "mit" else "Failed to find" with pytest.raises(krb5.Krb5Error, match=expected): krb5.init_creds_set_keytab(ctx, creds_ctx, kt) def test_init_creds_set_password(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() princ = krb5.parse_name_flags(ctx, realm.user_princ.encode()) creds_ctx = krb5.init_creds_init(ctx, princ) assert isinstance(creds_ctx, krb5.InitCredsContext) assert str(creds_ctx) == "InitCredsContext" krb5.init_creds_set_password(ctx, creds_ctx, realm.password("user").encode()) krb5.init_creds_get(ctx, creds_ctx) creds = krb5.init_creds_get_creds(ctx, creds_ctx) assert isinstance(creds, krb5.Creds) assert str(creds) == "Creds" def test_init_creds_set_password_invalid(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() princ = krb5.parse_name_flags(ctx, realm.user_princ.encode()) creds_ctx = krb5.init_creds_init(ctx, princ) assert isinstance(creds_ctx, krb5.InitCredsContext) assert str(creds_ctx) == "InitCredsContext" krb5.init_creds_set_password(ctx, creds_ctx, b"invalid") # Too many different error messages - just expect an error with pytest.raises(krb5.Krb5Error): krb5.init_creds_get(ctx, creds_ctx) def test_renew_creds(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() princ = krb5.parse_name_flags(ctx, realm.user_princ.encode()) opt = krb5.get_init_creds_opt_alloc(ctx) # Ask for a renewable ticket krb5.get_init_creds_opt_set_renew_life(opt, 1024) creds = krb5.get_init_creds_password(ctx, princ, opt, realm.password("user").encode()) assert creds.client.name == realm.user_princ.encode() assert creds.server.name == b"krbtgt/KRBTEST.COM@KRBTEST.COM" assert krb5.TicketFlags.initial in creds.ticket_flags assert krb5.TicketFlags.renewable in creds.ticket_flags flags_raw = creds.ticket_flags_raw flags_raw_reversed = 0 for i in range(32): if flags_raw & (1 << i): flags_raw_reversed |= 1 << (31 - i) if realm.provider.lower() == "heimdal": assert creds.ticket_flags == flags_raw else: assert creds.ticket_flags == flags_raw_reversed cc = krb5.cc_new_unique(ctx, b"MEMORY") krb5.cc_initialize(ctx, cc, princ) krb5.cc_store_cred(ctx, cc, creds) new_creds = krb5.get_renewed_creds(ctx, creds.client, cc) assert new_creds.client.name == realm.user_princ.encode() assert new_creds.server.name == b"krbtgt/KRBTEST.COM@KRBTEST.COM" if realm.provider.lower() == "heimdal": # The MIT KDC seems to return renewed tickets with the 'initial' flag # set. assert krb5.TicketFlags.initial not in new_creds.ticket_flags new_creds = krb5.get_renewed_creds(ctx, creds.client, cc, b"krbtgt/KRBTEST.COM@KRBTEST.COM") assert new_creds.client.name == realm.user_princ.encode() assert new_creds.server.name == b"krbtgt/KRBTEST.COM@KRBTEST.COM" if realm.provider.lower() == "heimdal": assert krb5.TicketFlags.initial not in new_creds.ticket_flags @pytest.mark.requires_api("get_validated_creds") def test_validate_creds(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() princ = krb5.parse_name_flags(ctx, realm.user_princ.encode()) opt = krb5.get_init_creds_opt_alloc(ctx) # Get postdated ticket, ticket will be valid after 1s creds = krb5.get_init_creds_password(ctx, princ, opt, realm.password("user").encode(), start_time=1) assert creds.client.name == realm.user_princ.encode() assert creds.server.name == b"krbtgt/KRBTEST.COM@KRBTEST.COM" # Ticket flags for creds should have TKT_FLG_POSTDATED and TKT_FLG_INVALID set assert krb5.TicketFlags.postdated in creds.ticket_flags assert krb5.TicketFlags.invalid in creds.ticket_flags cc = krb5.cc_new_unique(ctx, b"MEMORY") krb5.cc_initialize(ctx, cc, princ) krb5.cc_store_cred(ctx, cc, creds) start_time = time.time() while True: try: new_creds = krb5.get_validated_creds(ctx, creds.client, cc) break except krb5.Krb5Error as e: # Retry within the first 5s when the error is # KRB5KRB_AP_ERR_TKT_NYV ("Ticket not yet valid"). The ticket should # normally be valid after 0-1s. if (time.time() - start_time < 5) and e.err_code == -1765328351: # Retry time.sleep(0.1) else: raise assert new_creds.client.name == realm.user_princ.encode() assert new_creds.server.name == b"krbtgt/KRBTEST.COM@KRBTEST.COM" # Ticket flags for new_creds should have TKT_FLG_POSTDATED set and TKT_FLG_INVALID cleared assert krb5.TicketFlags.postdated in new_creds.ticket_flags assert krb5.TicketFlags.invalid not in new_creds.ticket_flags new_creds = krb5.get_validated_creds(ctx, creds.client, cc, b"krbtgt/KRBTEST.COM@KRBTEST.COM") assert new_creds.client.name == realm.user_princ.encode() assert new_creds.server.name == b"krbtgt/KRBTEST.COM@KRBTEST.COM" # Ticket flags for new_creds should have TKT_FLG_POSTDATED set and TKT_FLG_INVALID cleared assert krb5.TicketFlags.postdated in new_creds.ticket_flags assert krb5.TicketFlags.invalid not in new_creds.ticket_flags @pytest.mark.requires_api("get_etype_info") def test_get_etype_info(realm: k5test.K5Realm, tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() princ = krb5.parse_name_flags(ctx, realm.user_princ.encode()) # Get information about etype, salt and s2kparams for the principal etype, salt, s2kparams = krb5.get_etype_info(ctx, princ) # Check whether the KDC returned the etype-info if salt is None: raise Exception("Failed to get etype-info") # Use the string-to-key function to get the user's key kb = krb5.c_string_to_key(ctx, etype, realm.password("user").encode(), salt, s2kparams) # Write the key into a keytab kt = krb5.kt_resolve(ctx, f"FILE:{tmp_path / 'keytab'}".encode()) krb5.kt_add_entry(ctx, kt, princ, 1, 0, kb) # Get credentials using this keytab opt = krb5.get_init_creds_opt_alloc(ctx) creds = krb5.get_init_creds_keytab(ctx, princ, opt, kt) # Verify the credentials assert creds.client.name == realm.user_princ.encode() assert creds.server.name == b"krbtgt/KRBTEST.COM@KRBTEST.COM" @pytest.mark.requires_api("marshal_credentials") def test_creds_serialization(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() princ = krb5.parse_name_flags(ctx, realm.user_princ.encode()) opt = krb5.get_init_creds_opt_alloc(ctx) creds = krb5.get_init_creds_password(ctx, princ, opt, realm.password("user").encode()) assert isinstance(creds, krb5.Creds) with pytest.raises(krb5.Krb5Error): krb5.unmarshal_credentials(ctx, b"invalid") with pytest.raises(krb5.Krb5Error): krb5.unmarshal_credentials(ctx, b"") marshalled_actual = krb5.marshal_credentials(ctx, creds) assert isinstance(marshalled_actual, bytes) assert len(marshalled_actual) > 0 uncreds = krb5.unmarshal_credentials(ctx, marshalled_actual) assert isinstance(uncreds, krb5.Creds) assert str(uncreds) == "Creds" assert id(creds) != id(uncreds) assert creds.client.name == uncreds.client.name assert creds.ticket == uncreds.ticket assert creds.keyblock.data == uncreds.keyblock.data assert creds.times.endtime == uncreds.times.endtime pykrb5-0.8.0/tests/test_creds_opt.py000066400000000000000000000127061505521762700175100ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import os import k5test import pytest import krb5 def test_get_init_creds_opt_alloc() -> None: ctx = krb5.init_context() opt = krb5.get_init_creds_opt_alloc(ctx) assert isinstance(opt, krb5.GetInitCredsOpt) assert str(opt) == "GetInitCredsOpt" def test_get_init_creds_opt_set_anonymous() -> None: ctx = krb5.init_context() opt = krb5.get_init_creds_opt_alloc(ctx) krb5.get_init_creds_opt_set_anonymous(opt, True) krb5.get_init_creds_opt_set_anonymous(opt, False) def test_get_init_creds_opt_set_canonicalize() -> None: ctx = krb5.init_context() opt = krb5.get_init_creds_opt_alloc(ctx) krb5.get_init_creds_opt_set_canonicalize(opt, True) krb5.get_init_creds_opt_set_canonicalize(opt, False) def test_get_init_creds_opt_set_etype_list() -> None: ctx = krb5.init_context() opt = krb5.get_init_creds_opt_alloc(ctx) krb5.get_init_creds_opt_set_etype_list(opt, [17, 18]) krb5.get_init_creds_opt_set_etype_list(opt, []) def test_get_init_creds_opt_set_forwardable() -> None: ctx = krb5.init_context() opt = krb5.get_init_creds_opt_alloc(ctx) krb5.get_init_creds_opt_set_forwardable(opt, True) krb5.get_init_creds_opt_set_forwardable(opt, False) def test_get_init_creds_opt_set_proxiable() -> None: ctx = krb5.init_context() opt = krb5.get_init_creds_opt_alloc(ctx) krb5.get_init_creds_opt_set_proxiable(opt, True) krb5.get_init_creds_opt_set_proxiable(opt, False) def test_get_init_creds_opt_set_renew_life() -> None: ctx = krb5.init_context() opt = krb5.get_init_creds_opt_alloc(ctx) krb5.get_init_creds_opt_set_renew_life(opt, 0) krb5.get_init_creds_opt_set_renew_life(opt, 1) krb5.get_init_creds_opt_set_renew_life(opt, 1024) def test_get_init_creds_opt_set_salt() -> None: ctx = krb5.init_context() opt = krb5.get_init_creds_opt_alloc(ctx) krb5.get_init_creds_opt_set_salt(opt, b"\x00") def test_get_init_creds_opt_set_salt_invalid_empty_string() -> None: ctx = krb5.init_context() opt = krb5.get_init_creds_opt_alloc(ctx) with pytest.raises(ValueError, match="salt cannot be an empty byte string"): krb5.get_init_creds_opt_set_salt(opt, b"") def test_get_init_creds_opt_set_tkt_life() -> None: ctx = krb5.init_context() opt = krb5.get_init_creds_opt_alloc(ctx) krb5.get_init_creds_opt_set_tkt_life(opt, 0) krb5.get_init_creds_opt_set_tkt_life(opt, 1) krb5.get_init_creds_opt_set_tkt_life(opt, 1024) @pytest.mark.requires_api("get_init_creds_opt_set_fast_flags") def test_get_init_creds_opt_set_fast_flags() -> None: ctx = krb5.init_context() opt = krb5.get_init_creds_opt_alloc(ctx) krb5.get_init_creds_opt_set_fast_flags(ctx, opt, krb5.FastFlags.required) krb5.get_init_creds_opt_set_fast_flags(ctx, opt, krb5.FastFlags.none) @pytest.mark.requires_api("get_init_creds_opt_set_fast_ccache") def test_get_init_creds_opt_set_fast_ccache() -> None: ctx = krb5.init_context() opt = krb5.get_init_creds_opt_alloc(ctx) cc = krb5.cc_new_unique(ctx, b"MEMORY") krb5.get_init_creds_opt_set_fast_ccache(ctx, opt, cc) @pytest.mark.requires_api("get_init_creds_opt_set_fast_ccache_name") def test_get_init_creds_opt_set_fast_ccache_name() -> None: ctx = krb5.init_context() opt = krb5.get_init_creds_opt_alloc(ctx) cc = krb5.cc_new_unique(ctx, b"MEMORY") krb5.get_init_creds_opt_set_fast_ccache_name(ctx, opt, (cc.cache_type or b"") + b":" + (cc.name or b"")) @pytest.mark.requires_api("get_init_creds_opt_set_in_ccache") def test_get_init_creds_opt_set_in_ccache() -> None: ctx = krb5.init_context() opt = krb5.get_init_creds_opt_alloc(ctx) cc = krb5.cc_new_unique(ctx, b"MEMORY") krb5.get_init_creds_opt_set_in_ccache(ctx, opt, cc) @pytest.mark.requires_api("get_init_creds_opt_set_out_ccache") def test_get_init_creds_opt_set_out_ccache() -> None: ctx = krb5.init_context() ccache = krb5.cc_new_unique(ctx, b"MEMORY") opt = krb5.get_init_creds_opt_alloc(ctx) krb5.get_init_creds_opt_set_out_ccache(ctx, opt, ccache) @pytest.mark.requires_api("get_init_creds_opt_set_pac_request") def test_get_init_creds_opt_set_pac_request() -> None: ctx = krb5.init_context() opt = krb5.get_init_creds_opt_alloc(ctx) krb5.get_init_creds_opt_set_pac_request(ctx, opt, True) krb5.get_init_creds_opt_set_pac_request(ctx, opt, False) @pytest.mark.requires_api("get_init_creds_opt_set_default_flags") def test_get_init_creds_opt_set_default_flags() -> None: ctx = krb5.init_context() opt = krb5.get_init_creds_opt_alloc(ctx) krb5.get_init_creds_opt_set_default_flags(ctx, opt) krb5.get_init_creds_opt_set_default_flags(ctx, opt, b"appname", b"realm") @pytest.mark.requires_api("get_init_creds_opt_set_pa") def test_get_init_creds_opt_set_pa() -> None: ctx = krb5.init_context() opt = krb5.get_init_creds_opt_alloc(ctx) krb5.get_init_creds_opt_set_pa(ctx, opt, b"attr", b"value") @pytest.mark.requires_api("get_init_creds_opt_set_pa") def test_get_init_creds_opt_set_pa_invalid_empty_value() -> None: ctx = krb5.init_context() opt = krb5.get_init_creds_opt_alloc(ctx) with pytest.raises(ValueError, match="attr must be set"): krb5.get_init_creds_opt_set_pa(ctx, opt, b"", b"value") with pytest.raises(ValueError, match="value must be set"): krb5.get_init_creds_opt_set_pa(ctx, opt, b"attr", b"") pykrb5-0.8.0/tests/test_keyblock.py000066400000000000000000000034651505521762700173330ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import pytest import krb5 def test_init_keyblock_empty() -> None: ctx = krb5.init_context() kb = krb5.init_keyblock(ctx, 0, None) assert len(kb) == 0 assert kb.enctype == 0 assert kb.data == b"" assert str(kb) == "KeyBlock 0" assert repr(kb) == "KeyBlock(enctype=0, length=0)" def test_init_keyblock_data() -> None: ctx = krb5.init_context() kb = krb5.init_keyblock(ctx, 17, b"\xff" * 16) assert len(kb) == 16 assert kb.enctype == 17 assert kb.data == b"\xff" * 16 assert str(kb) == "KeyBlock 17" assert repr(kb) == "KeyBlock(enctype=17, length=16)" @pytest.mark.requires_api("c_string_to_key") def test_c_string_to_key() -> None: ctx = krb5.init_context() salt = b"EXAMPLE.COMtestuser" password = b"Some Password" kb = krb5.c_string_to_key(ctx, 17, salt, password) assert kb.enctype == 17 assert len(kb) == 16 assert kb.data == b"\xd2\x153\xcd\xd9\x7fR\xe6\x11U]7\xac\x12[\xf6" kb = krb5.c_string_to_key(ctx, 17, salt, password, b"\x00\x00\x10\x00") assert kb.enctype == 17 assert len(kb) == 16 assert kb.data == b"\xd2\x153\xcd\xd9\x7fR\xe6\x11U]7\xac\x12[\xf6" kb = krb5.c_string_to_key(ctx, 18, salt, password, b"\x00\x00\x10\x00") assert kb.enctype == 18 assert len(kb) == 32 assert kb.data == b"\x0b\x12\x05\xb0\xc4\xe7\x0e\xf1\xbf\xf5\xeaJ\x1a\x80?~@m\x7f\xcakPk\x08\xa6\x99\x15\xd6s\r&(" kb = krb5.c_string_to_key(ctx, 18, salt, password, b"\x00\x01\x23\x45") assert kb.enctype == 18 assert len(kb) == 32 assert ( kb.data == b"\x11\xcc\x10\x0e\xff$\xc1SL^d\x00\xe2\x83\x08\xefxM\x12\x92\x18:\x1c\x9b\xd2w\xf5\xfd\xb9\x13\xe5\xd1" ) pykrb5-0.8.0/tests/test_kt.py000066400000000000000000000247711505521762700161510ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import copy import pathlib import k5test import pytest import krb5 def test_kt_default(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() kt = krb5.kt_default(ctx) assert isinstance(kt, krb5.KeyTab) assert isinstance(kt.addr, int) assert kt.name == realm.keytab.encode() assert kt.kt_type == b"FILE" assert repr(kt) == f"KeyTab(kt_type=FILE, name={realm.keytab})" assert str(kt) == f"FILE:{realm.keytab}" def test_kt_default_name(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() actual = krb5.kt_default_name(ctx) assert actual == realm.keytab.encode() def test_kt_get_name(realm: k5test.K5Realm, tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() kt = krb5.kt_resolve(ctx, f"FILE:{tmp_path / 'keytab'}".encode()) actual = krb5.kt_get_name(ctx, kt) if realm.provider == "mit": assert actual == f"FILE:{tmp_path / 'keytab'}".encode() else: assert actual == f"{tmp_path / 'keytab'}".encode() def test_kt_get_full_name(tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() kt = krb5.kt_resolve(ctx, f"FILE:{tmp_path / 'keytab'}".encode()) assert krb5.kt_get_full_name(ctx, kt) == f"FILE:{tmp_path / 'keytab'}".encode() def test_kt_get_type(tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() kt = krb5.kt_resolve(ctx, f"FILE:{tmp_path / 'keytab'}".encode()) assert krb5.kt_get_type(ctx, kt) == b"FILE" def test_kt_enumerate(realm: k5test.K5Realm, tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() kt = krb5.kt_resolve(ctx, f"FILE:{tmp_path / 'keytab'}".encode()) msg_pattern = "Key table file '.*' not found" if realm.provider == "mit" else "No such file or directory" with pytest.raises(krb5.Krb5Error, match=msg_pattern): list(kt) princ = krb5.parse_name_flags(ctx, b"user@DOMAIN.COM") key_block = krb5.init_keyblock(ctx, 17, b"\x00" * 16) krb5.kt_add_entry(ctx, kt, princ, 1, 0, key_block) entries = list(kt) assert len(entries) == 1 assert entries[0].principal.name == b"user@DOMAIN.COM" assert entries[0].kvno == 1 assert isinstance(entries[0].timestamp, int) copied_princ = copy.copy(entries[0].principal) krb5.kt_remove_entry(ctx, kt, entries[0]) del entries[0] entries = list(kt) assert entries == [] # Tests that the copied principal outlives the kt/entry del kt assert copied_princ.name == b"user@DOMAIN.COM" def test_kt_get_entry_empty(realm: k5test.K5Realm, tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() kt = krb5.kt_resolve(ctx, f"FILE:{tmp_path / 'keytab'}".encode()) princ = krb5.parse_name_flags(ctx, b"user@DOMAIN.COM") msg_pattern = "Key table file '.*' not found" if realm.provider == "mit" else "No such file or directory" with pytest.raises(krb5.Krb5Error, match=msg_pattern): krb5.kt_get_entry(ctx, kt, princ) def test_kt_get_entry(realm: k5test.K5Realm, tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() kt = krb5.kt_resolve(ctx, f"FILE:{tmp_path / 'keytab'}".encode()) princ = krb5.parse_name_flags(ctx, b"user@DOMAIN.COM") key_block = krb5.init_keyblock(ctx, 17, b"\xff" * 16) assert key_block.enctype == 17 assert key_block.data == b"\xff" * 16 krb5.kt_add_entry(ctx, kt, princ, 1, 0, key_block) entry = krb5.kt_get_entry(ctx, kt, princ) assert entry.principal.name == princ.name assert entry.kvno == 1 assert entry.key.enctype == 17 assert entry.key.data == key_block.data krb5.kt_remove_entry(ctx, kt, entry) assert list(kt) == [] msg_pattern = "No key table entry found" if realm.provider == "mit" else "Failed to find .* in keytab .*" with pytest.raises(krb5.Krb5Error, match=msg_pattern): krb5.kt_get_entry(ctx, kt, princ) def test_kt_get_entry_multiple_kvno(realm: k5test.K5Realm, tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() kt = krb5.kt_resolve(ctx, f"FILE:{tmp_path / 'keytab'}".encode()) princ = krb5.parse_name_flags(ctx, b"user@DOMAIN.COM") key_block = krb5.init_keyblock(ctx, 17, b"\x00" * 16) krb5.kt_add_entry(ctx, kt, princ, 1, 0, key_block) krb5.kt_add_entry(ctx, kt, princ, 2, 0, key_block) entry = krb5.kt_get_entry(ctx, kt, princ) assert entry.principal.name == princ.name assert entry.kvno == 2 entry = krb5.kt_get_entry(ctx, kt, princ, kvno=1) assert entry.principal.name == princ.name assert entry.kvno == 1 msg_pattern = ( "Key version number for principal in key table is incorrect" if realm.provider == "mit" else "Failed to find .* in keytab .*" ) with pytest.raises(krb5.Krb5Error, match=msg_pattern): krb5.kt_get_entry(ctx, kt, princ, kvno=3) def test_kt_get_entry_multiple_enctype(realm: k5test.K5Realm, tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() kt = krb5.kt_resolve(ctx, f"FILE:{tmp_path / 'keytab'}".encode()) princ = krb5.parse_name_flags(ctx, b"user@DOMAIN.COM") krb5.kt_add_entry(ctx, kt, princ, 1, 0, krb5.init_keyblock(ctx, 17, b"\x00" * 16)) krb5.kt_add_entry(ctx, kt, princ, 2, 0, krb5.init_keyblock(ctx, 18, b"\x00" * 32)) entry = krb5.kt_get_entry(ctx, kt, princ) assert entry.principal.name == princ.name assert entry.kvno == 2 assert entry.key.enctype == 18 entry = krb5.kt_get_entry(ctx, kt, princ, enctype=17) assert entry.principal.name == princ.name assert entry.kvno == 1 assert entry.key.enctype == 17 msg_pattern = "No key table entry found" if realm.provider == "mit" else "Failed to find .* in keytab .*" with pytest.raises(krb5.Krb5Error, match=msg_pattern): krb5.kt_get_entry(ctx, kt, princ, enctype=16) def test_kt_read_service_key_empty(realm: k5test.K5Realm, tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() kt = krb5.kt_resolve(ctx, f"FILE:{tmp_path / 'keytab'}".encode()) princ = krb5.parse_name_flags(ctx, b"user@DOMAIN.COM") msg_pattern = "Key table file '.*' not found" if realm.provider == "mit" else "No such file or directory" with pytest.raises(krb5.Krb5Error, match=msg_pattern): krb5.kt_read_service_key(ctx, kt.name, princ) def test_kt_read_service_key(tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() kt = krb5.kt_resolve(ctx, f"FILE:{tmp_path / 'keytab'}".encode()) princ = krb5.parse_name_flags(ctx, b"user@DOMAIN.COM") key_block = krb5.init_keyblock(ctx, 17, b"\xff" * 16) assert key_block.enctype == 17 assert key_block.data == b"\xff" * 16 krb5.kt_add_entry(ctx, kt, princ, 1, 0, key_block) key = krb5.kt_read_service_key(ctx, kt.name, princ) assert key.enctype == 17 assert key.data == b"\xff" * 16 def test_kt_read_service_key_multiple_kvno(realm: k5test.K5Realm, tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() kt = krb5.kt_resolve(ctx, f"FILE:{tmp_path / 'keytab'}".encode()) princ = krb5.parse_name_flags(ctx, b"user@DOMAIN.COM") krb5.kt_add_entry(ctx, kt, princ, 1, 0, krb5.init_keyblock(ctx, 17, b"\x00" * 16)) krb5.kt_add_entry(ctx, kt, princ, 2, 0, krb5.init_keyblock(ctx, 18, b"\x11" * 32)) key = krb5.kt_read_service_key(ctx, kt.name, princ) assert key.enctype == 18 assert key.data == b"\x11" * 32 key = krb5.kt_read_service_key(ctx, kt.name, princ, kvno=1) assert key.enctype == 17 assert key.data == b"\x00" * 16 msg_pattern = ( "Key version number for principal in key table is incorrect" if realm.provider == "mit" else "Failed to find .* in keytab .*" ) with pytest.raises(krb5.Krb5Error, match=msg_pattern): krb5.kt_read_service_key(ctx, kt.name, princ, kvno=3) def test_kt_read_service_key_multiple_enctype(realm: k5test.K5Realm, tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() kt = krb5.kt_resolve(ctx, f"FILE:{tmp_path / 'keytab'}".encode()) princ = krb5.parse_name_flags(ctx, b"user@DOMAIN.COM") krb5.kt_add_entry(ctx, kt, princ, 1, 0, krb5.init_keyblock(ctx, 17, b"\x00" * 16)) krb5.kt_add_entry(ctx, kt, princ, 2, 0, krb5.init_keyblock(ctx, 18, b"\x11" * 32)) key = krb5.kt_read_service_key(ctx, kt.name, princ) assert key.enctype == 18 assert key.data == b"\x11" * 32 key = krb5.kt_read_service_key(ctx, kt.name, princ, enctype=17) assert key.enctype == 17 assert key.data == b"\x00" * 16 msg_pattern = "No key table entry found" if realm.provider == "mit" else "Failed to find .* in keytab .*" with pytest.raises(krb5.Krb5Error, match=msg_pattern): krb5.kt_read_service_key(ctx, kt.name, princ, enctype=16) def test_kt_resolve(tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() kt = krb5.kt_resolve(ctx, f"FILE:{tmp_path / 'keytab'}".encode()) assert isinstance(kt, krb5.KeyTab) assert kt.kt_type == b"FILE" assert kt.name == f"{tmp_path / 'keytab'}".encode() assert str(kt) == f"FILE:{tmp_path / 'keytab'}" assert repr(kt) == f"KeyTab(kt_type=FILE, name={tmp_path / 'keytab'})" @pytest.mark.requires_api("kt_client_default") def test_kt_client_default(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() kt = krb5.kt_client_default(ctx) assert isinstance(kt, krb5.KeyTab) assert isinstance(kt.addr, int) assert kt.name == realm.client_keytab.encode() assert kt.kt_type == b"FILE" assert repr(kt) == f"KeyTab(kt_type=FILE, name={realm.client_keytab})" assert str(kt) == f"FILE:{realm.client_keytab}" @pytest.mark.requires_api("kt_dup") def test_kt_dup(tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() kt = krb5.kt_resolve(ctx, f"FILE:{tmp_path / 'keytab'}".encode()) kt_name = kt.name kt_addr = kt.addr copied_kt = krb5.kt_dup(ctx, kt) del kt assert isinstance(copied_kt, krb5.KeyTab) assert copied_kt.kt_type == b"FILE" assert copied_kt.name == kt_name assert copied_kt.addr != kt_addr @pytest.mark.requires_api("kt_have_content") def test_kt_have_content(tmp_path: pathlib.Path) -> None: ctx = krb5.init_context() kt = krb5.kt_resolve(ctx, f"FILE:{tmp_path / 'keytab'}".encode()) assert krb5.kt_have_content(ctx, kt) is False princ = krb5.parse_name_flags(ctx, b"user@DOMAIN.COM") key_block = krb5.init_keyblock(ctx, 17, b"\x00" * 16) krb5.kt_add_entry(ctx, kt, princ, 1, 0, key_block) assert krb5.kt_have_content(ctx, kt) entry = list(kt)[0] krb5.kt_remove_entry(ctx, kt, entry) assert krb5.kt_have_content(ctx, kt) is False pykrb5-0.8.0/tests/test_principal.py000066400000000000000000000155561505521762700175150ustar00rootroot00000000000000# Copyright: (c) 2021 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import k5test import pytest import krb5 def test_parse_principal(realm: k5test.K5Realm) -> None: name = f"role/abc\\/def\\@test@{realm.realm}" ctx = krb5.init_context() principal = krb5.parse_name_flags(ctx, name.encode()) assert isinstance(principal, krb5.Principal) assert str(principal) == name assert repr(principal) == f"Principal({name})" assert principal.name == name.encode() assert isinstance(principal.addr, int) no_flags = krb5.parse_name_flags(ctx, name.encode(), flags=krb5.PrincipalParseFlags.none) assert isinstance(principal, krb5.Principal) assert str(principal) == str(no_flags) no_realm = krb5.parse_name_flags(ctx, b"role/abc\\/def\\@test", flags=krb5.PrincipalParseFlags.no_realm) assert isinstance(no_realm, krb5.Principal) if realm.provider == "mit": # MIT seems to have a bug here assert str(no_realm) == "role/abc\\/def@test" else: assert str(no_realm) == "role/abc\\/def\\@test" require_realm = krb5.parse_name_flags(ctx, name.encode(), flags=krb5.PrincipalParseFlags.require_realm) assert isinstance(require_realm, krb5.Principal) assert str(require_realm) == name enterprise = krb5.parse_name_flags(ctx, name.encode(), flags=krb5.PrincipalParseFlags.enterprise) assert isinstance(enterprise, krb5.Principal) assert str(enterprise) == f"role\\/abc\\/def\\@test\\@{realm.realm}@{realm.realm}" ignore_realm = krb5.parse_name_flags(ctx, name.encode(), flags=krb5.PrincipalParseFlags.ignore_realm) assert isinstance(ignore_realm, krb5.Principal) if realm.provider == "mit": assert str(ignore_realm) == "role/abc\\/def@test" else: assert str(ignore_realm) == "role/abc\\/def\\@test" def test_parse_principal_no_realm_failure(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() expected = "has realm present" if realm.provider == "mit" else "realm found in" with pytest.raises(krb5.Krb5Error, match=expected): krb5.parse_name_flags(ctx, realm.user_princ.encode(), flags=krb5.PrincipalParseFlags.no_realm) def test_unparse_principal(realm: k5test.K5Realm) -> None: name = f"role/abc\\/def\\@test@{realm.realm}" ctx = krb5.init_context() principal = krb5.parse_name_flags(ctx, name.encode()) normal = krb5.unparse_name_flags(ctx, principal) assert normal == b"role/abc\\/def\\@test@" + realm.realm.encode() no_flags = krb5.unparse_name_flags(ctx, principal, flags=krb5.PrincipalUnparseFlags.none) assert no_flags == normal no_realm = krb5.unparse_name_flags(ctx, principal, flags=krb5.PrincipalUnparseFlags.no_realm) if realm.provider == "mit": # MIT seems to have a bug here assert no_realm == b"role/abc\\/def@test" else: assert no_realm == b"role/abc\\/def\\@test" display = krb5.unparse_name_flags(ctx, principal, flags=krb5.PrincipalUnparseFlags.display) assert display == b"role/abc/def@test@" + realm.realm.encode() short = krb5.unparse_name_flags(ctx, principal, flags=krb5.PrincipalUnparseFlags.short) assert short == b"role/abc\\/def\\@test" krb5.set_default_realm(ctx, b"NEW.REALM") short = krb5.unparse_name_flags(ctx, principal, flags=krb5.PrincipalUnparseFlags.short) assert short == b"role/abc\\/def\\@test@" + realm.realm.encode() @pytest.mark.requires_api("principal_get_realm") def test_principal_get_realm() -> None: ctx = krb5.init_context() principal = krb5.parse_name_flags(ctx, b"username@REALM.COM") realm = krb5.principal_get_realm(ctx, principal) assert realm == b"REALM.COM" def test_principal_accessors() -> None: ctx = krb5.init_context() principal = krb5.parse_name_flags(ctx, b"someservice//name\\/with\\/slashes@REALM.COM") realm_name = principal.realm assert realm_name == b"REALM.COM" components = principal.components assert len(components) == 3 assert components[0] == b"someservice" assert components[1] == b"" assert components[2] == b"name/with/slashes" ty = principal.type assert ty == krb5.NameType.unknown or ty == krb5.NameType.principal def test_name_type() -> None: unknown_name_type = krb5.NameType(200) assert unknown_name_type.name == "Unknown_NameType_200" assert unknown_name_type.value == 200 unknown_neg_name_type = krb5.NameType(-300) assert unknown_neg_name_type.name == "Unknown_NameType_m300" assert unknown_neg_name_type.value == -300 assert krb5.NameType(4) is krb5.NameType.srv_xhst ctx = krb5.init_context() principal = krb5.build_principal(ctx, b"REALM.COM", [b"component"]) principal.type = krb5.NameType(-300) assert principal.type is unknown_neg_name_type def test_build_principal() -> None: ctx = krb5.init_context() principal = krb5.build_principal(ctx, b"REALM.COM", [b"someservice", b"", b"name/with/slashes"]) name = principal.name assert name == b"someservice//name\\/with\\/slashes@REALM.COM" realm_name = principal.realm assert realm_name == b"REALM.COM" components = principal.components assert len(components) == 3 assert components[0] == b"someservice" assert components[1] == b"" assert components[2] == b"name/with/slashes" ty = principal.type assert ty == krb5.NameType.principal principal = krb5.build_principal(ctx, b"REALM.COM", [b"krbtgt", b"REALM.COM"]) name = principal.name assert name == b"krbtgt/REALM.COM@REALM.COM" ty = principal.type assert ty == krb5.NameType.srv_inst principal = krb5.build_principal(ctx, b"WELLKNOWN:ANONYMOUS", [b"WELLKNOWN", b"ANONYMOUS"]) name = principal.name assert name == b"WELLKNOWN/ANONYMOUS@WELLKNOWN:ANONYMOUS" ty = principal.type assert ty == krb5.NameType.wellknown def test_principal_nul(realm: k5test.K5Realm) -> None: if realm.provider.lower() == "heimdal": pytest.skip("Heimdal does not support NUL bytes in realm or principal component strigns") ctx = krb5.init_context() principal = krb5.build_principal(ctx, b"REALM\0.COM", [b"some\0service", b"", b"name/with/slashes"]) name = principal.name assert name == b"some\\0service//name\\/with\\/slashes@REALM\\0.COM" realm_name = principal.realm assert realm_name == b"REALM\0.COM" components = principal.components assert len(components) == 3 assert components[0] == b"some\0service" assert components[1] == b"" assert components[2] == b"name/with/slashes" principal = krb5.parse_name_flags(ctx, b"some\\0service//name\\/with\\/slashes@REALM\\0.COM") realm_name = principal.realm assert realm_name == b"REALM\0.COM" components = principal.components assert len(components) == 3 assert components[0] == b"some\0service" assert components[1] == b"" assert components[2] == b"name/with/slashes" pykrb5-0.8.0/tests/test_string.py000066400000000000000000000030571505521762700170330ustar00rootroot00000000000000# Copyright: (c) 2022 Jordan Borean (@jborean93) # MIT License (see LICENSE or https://opensource.org/licenses/MIT) import k5test import pytest import krb5 def test_enctype_to_string(realm: k5test.K5Realm) -> None: expected = "AES-256 CTS mode with 96-bit SHA-1 HMAC" if realm.provider == "mit" else "aes256-cts-hmac-sha1-96" ctx = krb5.init_context() name = krb5.enctype_to_string(ctx, 18) assert name == expected def test_enctype_to_string_invalid(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() expected_msg = "Invalid argument" if realm.provider == "mit" else "encryption type \\d+ not supported" with pytest.raises(krb5.Krb5Error, match=expected_msg): krb5.enctype_to_string(ctx, 1024) def test_string_to_enctype() -> None: ctx = krb5.init_context() enctype = krb5.string_to_enctype(ctx, "aes256-cts-hmac-sha1-96") assert enctype == 18 def test_string_to_enctype_invalid(realm: k5test.K5Realm) -> None: ctx = krb5.init_context() expected_msg = "Invalid argument" if realm.provider == "mit" else "encryption type invalid not supported" with pytest.raises(krb5.Krb5Error, match=expected_msg): krb5.string_to_enctype(ctx, "invalid") @pytest.mark.requires_api("enctype_to_name") def test_string_to_name() -> None: name = krb5.enctype_to_name(18) assert name == "aes256-cts-hmac-sha1-96" @pytest.mark.requires_api("enctype_to_name") def test_string_to_name_shortest() -> None: name = krb5.enctype_to_name(18, shortest=True) assert name == "aes256-cts"