File fedora-crypto-policies-20210118.b21c811.obscpio of Package crypto-policies

Overview Repositories Revisions Requests Users Attributes Meta

File fedora-crypto-policies-20210118.b21c811.obscpio of Package crypto-policies (Revision 96bee8568d93a6aa7c3dda2166b7cb56)

Currently displaying revision 96bee8568d93a6aa7c3dda2166b7cb56 , Show latest

07070100000000000081A4000003E800000064000000016005CA76000002ED000000000000000000000000000000000000003700000000fedora-crypto-policies-20210118.b21c811/.gitlab-ci.ymlFedora-latest:
# When building CI for a particular system, adapt the image
  image: fedora:latest
  before_script:
  - dnf install --nogpgcheck -y openssh-clients openssh-server openssl git which gnutls-utils java-1.8.0-openjdk-devel bind perl asciidoc perl-generators libxslt 'perl(File::pushd)' 'perl(File::Temp)' 'perl(File::Copy)' libreswan dracut diffutils python3-pylint
  script:
  - pushd tests && git clone --depth 1 https://github.com/frozencemetery/krb5check && popd
  - make runpylint
  - make && make check
  - make install && make test-install >test-install.log 2>&1 && make test-fips-setup >test-fips-setup.log 2>&1
  tags:
  - shared
  except:
  - tags
  artifacts:
    expire_in: 2 weeks
    when: always
    paths:
      - ./*.log
07070100000001000081A4000003E800000064000000016005CA76000004E6000000000000000000000000000000000000003800000000fedora-crypto-policies-20210118.b21c811/CONTRIBUTING.md# Information about our contribution rules and coding style

Anyone is welcome to contribute to crypto-policies. Be prepared
to defend and justify your enhancements, and get through few rounds
of changes.

We try to stick to the following rules, so when contributing please
try to follow them too.

# Git commits:

Note that when contributing code you will need to assert that the contribution is
in accordance to the "Developer's Certificate of Origin" as found in the 
file [DCO.txt](doc/DCO.txt).

To indicate that, make sure that your contributions (patches or merge requests),
contain a "Signed-off-by" line, with your real name and e-mail address.

# Test suite:

New functionality should be accompanied by a test case which verifies
the correctness of crypto policies' operation on successful use of the new
functionality, as well as on fail cases. The test suite is run with "make check"
on target systems as well as on the CI system.

The tests can also be done at run-time, i.e., with the test_temp_policy()
function provided by back-ends, or on CI/target systems only (via check rule
in Makefile). The former implies the latter.

Any additional tools required for that testing should be listed in the CI
configuration (.gitlab-ci.yml).

07070100000002000081A4000003E800000064000000016005CA7600006740000000000000000000000000000000000000003700000000fedora-crypto-policies-20210118.b21c811/COPYING.LESSER		  GNU LESSER GENERAL PUBLIC LICENSE
		       Version 2.1, February 1999

Copyright (C) 1991, 1999 Free Software Foundation, Inc.
     51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

[This is the first released version of the Lesser GPL.  It also counts
 as the successor of the GNU Library Public License, version 2, hence
 the version number 2.1.]

Preamble

The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.

This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it.  You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.

When we speak of free software, we are referring to freedom of use,
not price.  Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.

To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights.  These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.

For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you.  You must make sure that they, too, receive or can get the source
code.  If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it.  And you must show them these terms so they know their rights.

We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.

To protect each distributor, we want to make it very clear that
there is no warranty for the free library.  Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.

Finally, software patents pose a constant threat to the existence of
any free program.  We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder.  Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.

Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License.  This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License.  We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.

When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library.  The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom.  The Lesser General
Public License permits more lax criteria for linking other code with
the library.

We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License.  It also provides other free software developers Less
of an advantage over competing non-free programs.  These disadvantages
are the reason we use the ordinary General Public License for many
libraries.  However, the Lesser license provides advantages in certain
special circumstances.

For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard.  To achieve this, non-free programs must be
allowed to use the library.  A more frequent case is that a free
library does the same job as widely used non-free libraries.  In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.

In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software.  For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.

Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.

The precise terms and conditions for copying, distribution and
modification follow.  Pay close attention to the difference between a
"work based on the library" and a "work that uses the library".  The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.

GNU LESSER GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".

A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.

The "Library", below, refers to any such software library or work
which has been distributed under these terms.  A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language.  (Hereinafter, translation is
included without limitation in the term "modification".)

"Source code" for a work means the preferred form of the work for
making modifications to it.  For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.

Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it).  Whether that is true depends on what the Library does
and what the program that uses the Library does.
  
  1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.

You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.

2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

a) The modified work must itself be a software library.

b) You must cause the files modified to carry prominent notices
    stating that you changed the files and the date of any change.

c) You must cause the whole of the work to be licensed at no
    charge to all third parties under the terms of this License.

d) If a facility in the modified Library refers to a function or a
    table of data to be supplied by an application program that uses
    the facility, other than as an argument passed when the facility
    is invoked, then you must make a good faith effort to ensure that,
    in the event an application does not supply such function or
    table, the facility still operates, and performs whatever part of
    its purpose remains meaningful.

(For example, a function in a library to compute square roots has
    a purpose that is entirely well-defined independent of the
    application.  Therefore, Subsection 2d requires that any
    application-supplied function or table used by this function must
    be optional: if the application does not supply it, the square
    root function must still compute square roots.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.

In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library.  To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License.  (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.)  Do not make any other change in
these notices.

Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.

This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.

4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.

If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.

5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library".  Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.

However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library".  The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.

When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library.  The
threshold for this to be true is not precisely defined by law.

If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work.  (Executables containing this object code plus portions of the
Library will still fall under Section 6.)

Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.

6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.

You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License.  You must supply a copy of this License.  If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License.  Also, you must do one
of these things:

a) Accompany the work with the complete corresponding
    machine-readable source code for the Library including whatever
    changes were used in the work (which must be distributed under
    Sections 1 and 2 above); and, if the work is an executable linked
    with the Library, with the complete machine-readable "work that
    uses the Library", as object code and/or source code, so that the
    user can modify the Library and then relink to produce a modified
    executable containing the modified Library.  (It is understood
    that the user who changes the contents of definitions files in the
    Library will not necessarily be able to recompile the application
    to use the modified definitions.)

b) Use a suitable shared library mechanism for linking with the
    Library.  A suitable mechanism is one that (1) uses at run time a
    copy of the library already present on the user's computer system,
    rather than copying library functions into the executable, and (2)
    will operate properly with a modified version of the library, if
    the user installs one, as long as the modified version is
    interface-compatible with the version that the work was made with.

c) Accompany the work with a written offer, valid for at
    least three years, to give the same user the materials
    specified in Subsection 6a, above, for a charge no more
    than the cost of performing this distribution.

d) If distribution of the work is made by offering access to copy
    from a designated place, offer equivalent access to copy the above
    specified materials from the same place.

e) Verify that the user has already received a copy of these
    materials or that you have already sent this user a copy.

For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it.  However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.

It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system.  Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.

7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:

a) Accompany the combined library with a copy of the same work
    based on the Library, uncombined with any other library
    facilities.  This must be distributed under the terms of the
    Sections above.

b) Give prominent notice with the combined library of the fact
    that part of it is a work based on the Library, and explaining
    where to find the accompanying uncombined form of the same work.

8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License.  Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License.  However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.

9. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Library or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.

10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.

11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all.  For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.

If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded.  In such case, this License incorporates the limitation as if
written in the body of this License.

13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.

Each version is given a distinguishing version number.  If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation.  If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.

14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission.  For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this.  Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.

NO WARRANTY

15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.

END OF TERMS AND CONDITIONS

How to Apply These Terms to Your New Libraries

If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change.  You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).

To apply these terms, attach the following notices to the library.  It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.

<one line to give the library's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

Also add information on how to contact you by electronic and paper mail.

You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary.  Here is a sample; alter the names:

Yoyodyne, Inc., hereby disclaims all copyright interest in the
  library `Frob' (a library for tweaking knobs) written by James Random Hacker.

<signature of Ty Coon>, 1 April 1990
  Ty Coon, President of Vice

That's all there is to it!

07070100000003000081A4000003E800000064000000016005CA7600000DB9000000000000000000000000000000000000003100000000fedora-crypto-policies-20210118.b21c811/MakefileVERSION=$(shell git log -1|grep commit|cut -f 2 -d ' '|head -c 7)
DIR?=/usr/share/crypto-policies
BINDIR?=/usr/bin
MANDIR?=/usr/share/man
CONFDIR?=/etc/crypto-policies
DESTDIR?=
MAN7PAGES=crypto-policies.7
MAN8PAGES=update-crypto-policies.8 fips-finish-install.8 fips-mode-setup.8
SCRIPTS=update-crypto-policies fips-finish-install fips-mode-setup
NUM_PROCS = $$(getconf _NPROCESSORS_ONLN)
PYVERSION = -3

all: build

build: $(MAN7PAGES) $(MAN8PAGES)
	mkdir -p output
	python/build-crypto-policies.py --reloadcmds policies output

install: $(MANPAGES)
	mkdir -p $(DESTDIR)$(MANDIR)
	mkdir -p $(DESTDIR)$(MANDIR)/man7
	mkdir -p $(DESTDIR)$(MANDIR)/man8
	mkdir -p $(DESTDIR)$(BINDIR)
	install -p -m 644 $(MAN7PAGES) $(DESTDIR)$(MANDIR)/man7
	install -p -m 644 $(MAN8PAGES) $(DESTDIR)$(MANDIR)/man8
	install -p -m 755 $(SCRIPTS) $(DESTDIR)$(BINDIR)
	mkdir -p $(DESTDIR)$(DIR)/
	install -p -m 644 default-config $(DESTDIR)$(DIR)
	install -p -m 644 output/reload-cmds.sh $(DESTDIR)$(DIR)
	for f in $$(find output -name '*.txt') ; do d=$$(dirname $$f | cut -f 2- -d '/')  ; install -p -m 644 -D -t $(DESTDIR)$(DIR)/$$d $$f ; done
	for f in $$(find policies -name '*.p*') ; do d=$$(dirname $$f)  ; install -p -m 644 -D -t $(DESTDIR)$(DIR)/$$d $$f ; done
	for f in $$(find python -name '*.py') ; do d=$$(dirname $$f) ; install -p -m 644 -D -t $(DESTDIR)$(DIR)/$$d $$f ; done
	chmod 755 $(DESTDIR)$(DIR)/python/update-crypto-policies.py
	chmod 755 $(DESTDIR)$(DIR)/python/build-crypto-policies.py

runpylint:
	@find python -name '*.py' -print|xargs -n1 --max-procs=$(NUM_PROCS) pylint$(PYVERSION) --rcfile=pylintrc
	@echo "[ OK ]"

check:
	python/build-crypto-policies.py --test --flat policies tests/outputs
	python/build-crypto-policies.py --policy FIPS:OSPP --test --flat policies tests/outputs
	python/build-crypto-policies.py --policy FIPS:ECDHE-ONLY --test --flat policies tests/outputs
	python/build-crypto-policies.py --policy DEFAULT:GOST --test --flat policies tests/outputs
	tests/openssl.pl
	tests/gnutls.pl
	tests/nss.py
	tests/java.pl
	tests/krb5.py
	top_srcdir=. tests/update-crypto-policies.sh

test: check runpylint

reset-outputs:
	@rm -rf tests/outputs/*
	@echo "Outputs were reset. Run make check to re-generate, and commit the output."

clean:
	rm -f $(MAN7PAGES) $(MAN8PAGES) *.?.xml
	rm -rf output

%: %.txt
	asciidoc.py -v -d manpage -b docbook $<
	xsltproc --nonet -o $@ /usr/share/asciidoc/docbook-xsl/manpage.xsl $@.xml

dist:
	rm -rf crypto-policies && git clone . crypto-policies && rm -rf crypto-policies/.git/ && tar -czf crypto-policies-git$(VERSION).tar.gz crypto-policies && rm -rf crypto-policies

test-install:
	current_policy="$$(update-crypto-policies --show)" ; \
	if [ -z "$$current_policy" ] ; then exit 1; fi ; \
	test_policy=LEGACY ; \
	if [ "$$current_policy" = LEGACY ] ; then test_policy=DEFAULT ; fi ; \
	update-crypto-policies --set $$test_policy || exit $$? ; \
	grep -q $$test_policy $(CONFDIR)/config || exit $$? ; \
	ls -l $(CONFDIR)/back-ends/ | grep -q $$current_policy && exit 2 ; \
	ls -l $(CONFDIR)/back-ends/ | grep -q $$test_policy || exit $$? ; \
	update-crypto-policies --is-applied | grep -q "is applied" || exit $$? ; \
	update-crypto-policies --set $$current_policy || exit $$? ; \
	ls -l $(CONFDIR)/back-ends/ | grep -q $$test_policy && exit 3 ; \
	ls -l $(CONFDIR)/back-ends/ | grep -q $$current_policy || exit $$? ; \
	update-crypto-policies --is-applied | grep -q "is applied" || exit $$?

test-fips-setup:
	CONFDIR=$(CONFDIR) ./tests/test-fips-setup.sh
07070100000004000081A4000003E800000064000000016005CA760000010F000000000000000000000000000000000000002D00000000fedora-crypto-policies-20210118.b21c811/NEWS* Fedora 28:
  - Added Ed25519, and Ed448 signature algorithms
  - Added RSA-PSS signatures algorithms with SHA1 and SHA2
  - Added notion of groups (i.e., including FFDHE), replacing
    the notion of curves.
  - gnutls: updated for new signature algorithms and groups

07070100000005000081A4000003E800000064000000016005CA76000009AC000000000000000000000000000000000000003200000000fedora-crypto-policies-20210118.b21c811/README.mdThis repository contains the crypto-policies data and scripts used in
Fedora.

|Release|Status|
|:-----:|:----:|
|master|[![build status](https://gitlab.com/redhat-crypto/fedora-crypto-policies/badges/master/pipeline.svg)](https://gitlab.com/redhat-crypto/fedora-crypto-policies/commits/master)|
|f32-updates|[![build status](https://gitlab.com/redhat-crypto/fedora-crypto-policies/badges/f32-updates/pipeline.svg)](https://gitlab.com/redhat-crypto/fedora-crypto-policies/commits/f32-updates)|
|rhel8|[![build status](https://gitlab.com/redhat-crypto/fedora-crypto-policies/badges/rhel8/pipeline.svg)](https://gitlab.com/redhat-crypto/fedora-crypto-policies/commits/rhel8)|

# Purpose

The purpose is to unify the crypto policies used by different applications
and libraries. That is allow setting a consistent security level for crypto
on all applications in a Fedora system, irrespective of the crypto library
in use.

# Description

The idea is to have few predefined security policies such as LEGACY, DEFAULT
and FUTURE which are set system-wide by the administrator. Then applications
that have no special needs will follow these policies by default. That
way the management of the various crypto applications and libraries used in a
system simplifies significantly.

The current implementations works by setting the desired policy in
/etc/crypto-policies/config. After this file is changed the script
'update-crypto-policies' should be executed, and the new policies
will activate.

The supported back ends in Fedora are:
 * GnuTLS
 * OpenSSL
 * NSS
 * BIND
 * libkrb5
 * OpenSSH
 * Java via OpenJDK
 * libssh

The documentation of crypto policies is at [update-crypto-policies.8.txt](update-crypto-policies.8.txt).

# Generating the policies

The policies are described in a simple policy language at `policies/POLICYFILE.pol`,
and they operate on strings defined at the beginning of `python/cryptopolicies.py`.
Individual application configuration generators are present in `python/policygenerators`.

To generate the policies per application use the script `python/build-crypto-policies.py
policydir DESTDIR` or `make install`.

For testing purpose the generated policies per application with the current
config are placed in `tests/outputs` and `make check` will verify whether the
generated policies match the stored. To reset the outputs use `make
reset-outputs` and `make check` to regenerate them.

# Contributing

See [our contribution guide](CONTRIBUTING.md).
07070100000006000081A4000003E800000064000000016005CA760000433E000000000000000000000000000000000000003E00000000fedora-crypto-policies-20210118.b21c811/crypto-policies.7.txt////
Copyright (C) 2019, 2020 Red Hat, Inc.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
////

crypto-policies(7)
==================
:doctype: manpage
:man source: crypto-policies

NAME
----
crypto-policies - system-wide crypto policies overview

DESCRIPTION
-----------
The security of cryptographic components of the operating system
does not remain constant over time. Algorithms, such as
cryptographic hashing and encryption, typically have a lifetime,
after which they are considered either too risky to use or plain insecure.
That means, we need to phase out such algorithms from the default
settings or completely disable them if they could cause an irreparable problem.

While in the past the algorithms were not disabled in a consistent way
and different applications applied different policies, the system-wide
crypto-policies followed by the crypto core components allow consistently
deprecating and disabling algorithms system-wide.

The individual policy levels (*DEFAULT*, *LEGACY*, *FUTURE*, and *FIPS*)
are included in the *crypto-policies(7)* package. In the future, there will
be also a mechanism for easy creation and deployment of policies defined
by the system administrator or a third party vendor.

For rationale, see *RFC 7457* for a list of attacks taking advantage of
legacy crypto algorithms.

COVERED APPLICATIONS
--------------------

Crypto-policies apply to the configuration of the core cryptographic subsystems,
covering *TLS*, *IKE*, *IPSec*, *DNSSec*, and *Kerberos* protocols; i.e., the
supported secure communications protocols on the base operating system.

Once an application runs in the operating system, it follows the default
or selected policy and refuses to fall back to algorithms and protocols not
within the policy, unless the user has explicitly requested the application
to do so. That is, the policy applies to the default behavior of applications
when running with the system-provided configuration but the user can override
it on an application-specific basis.

The policies currently provide settings for these applications and libraries:

* *BIND* DNS name server daemon
* *GnuTLS* TLS library
* *OpenJDK* runtime environment
* *Kerberos 5* library
* *Libreswan* IPsec and IKE protocol implementation
* *NSS* TLS library
* *OpenSSH* SSH2 protocol implementation
* *OpenSSL* TLS library
* *libssh* SSH2 protocol implementation

Applications using the above libraries and tools are covered by the
cryptographic policies unless they are explicitly configured not to be so.

PROVIDED POLICY LEVELS
----------------------

*LEGACY*::
  This policy ensures maximum compatibility with legacy systems; it is
  less secure and it includes support for *TLS 1.0*, *TLS 1.1*, and *SSH2*
  protocols or later. The algorithms *DSA*, *3DES*, and *RC4* are allowed,
  while *RSA* and *Diffie-Hellman* parameters are accepted if larger than 1023 bits.
  The level provides at least 64-bit security.

* MACs: all *HMAC* with *SHA-1* or better + all modern MACs (*Poly1305*
    etc.)
  * Curves: all prime >= 255 bits (including Bernstein curves)
  * Signature algorithms: with *SHA1* hash or better (*DSA* allowed)
  * *TLS* Ciphers: all available >= 112-bit key, >= 128-bit block (including
    *RC4* and *3DES*)
  * Non-TLS Ciphers: same as *TLS* ciphers with added *Camellia*
  * Key exchange: *ECDHE*, *RSA*, *DHE*
  * *DH* params size: >= 1023
  * *RSA* keys size: >= 1023
  * *DSA* params size: >= 1023
  * *TLS* protocols: *TLS* >= 1.0, *DTLS* >= 1.0

*DEFAULT*::
  The *DEFAULT* policy is a reasonable default policy for today's standards.
  It allows the *TLS 1.2*, and *TLS 1.3* protocols,
  as well as *IKEv2* and *SSH2*. The *Diffie-Hellman*
  parameters are accepted if they are at least 2048 bits long.
  The level provides at least 112-bit security with the exception of allowing
  *SHA-1* signatures in DNSSec where they are still prevalent.

* MACs: all *HMAC* with *SHA-1* or better + all modern MACs (*Poly1305*
    etc.)
  * Curves: all prime >= 255 bits (including Bernstein curves)
  * Signature algorithms: with *SHA-224* hash or better (no *DSA*)
  * *TLS* Ciphers: >= 128-bit key, >= 128-bit block (*AES*, *ChaCha20*,
    including *AES-CBC*)
  * non-TLS Ciphers: as *TLS* Ciphers with added *Camellia*
  * key exchange: *ECDHE*, *RSA*, *DHE* (no *DHE-DSS*)
  * *DH* params size: >= 2048
  * *RSA* keys size: >= 2048
  * *TLS* protocols: *TLS* >= 1.2, *DTLS* >= 1.2

*NEXT*::
  The *NEXT* policy is just an alias to the *DEFAULT* policy.

*FUTURE*::
  A conservative security level that is believed to withstand any near-term
  future attacks. This level does not allow the use of *SHA-1* in signature
  algorithms. The level also provides some (not complete) preparation for
  post-quantum encryption support in form of 256-bit symmetric encryption
  requirement. The *RSA* and *Diffie-Hellman* parameters are accepted if
  larger than 3071 bits. The level provides at least 128-bit security.

* MACs: all *HMAC* with *SHA-256* or better + all modern MACs (*Poly1305*
    etc.)
  * Curves: all prime >= 255 bits (including Bernstein curves)
  * Signature algorithms: with *SHA-256* hash or better (no *DSA*)
  * *TLS* Ciphers: >= 256-bit key, >= 128-bit block, only Authenticated
    Encryption (AE) ciphers
  * non-TLS Ciphers: same as *TLS* ciphers with added non AE ciphers and
    *Camellia*
  * key exchange: *ECDHE*, *DHE* (no *DHE-DSS*, no *RSA*)
  * *DH* params size: >= 3072
  * *RSA* keys size: >= 3072
  * *TLS* protocols: *TLS* >= 1.2, *DTLS* >= 1.2

*FIPS*::
  A level that conforms to the *FIPS 140-2* requirements. This policy is used
  internally by the *fips-mode-setup(8)* tool which can switch the system
  into the *FIPS 140-2* compliance mode.
  The level provides at least 112-bit security.

* MACs: all *HMAC* with *SHA1* or better
  * Curves: all prime >= 256 bits
  * Signature algorithms: with *SHA-256* hash or better (no *DSA*)
  * *TLS* Ciphers: >= 128-bit key, >= 128-bit block (*AES*,
    including *AES-CBC*)
  * non-TLS Ciphers: same as *TLS* Ciphers
  * key exchange: *ECDHE*, *DHE* (no *DHE-DSS*, no *RSA*)
  * *DH* params size: >= 2048
  * *RSA* params size: >= 2048
  * *TLS* protocols: *TLS* >= 1.2, *DTLS* >= 1.2

*EMPTY*::
  All cryptographic algorithms are disabled (used for debugging only, do not
  use).

CRYPTO POLICY DEFINITON FORMAT
------------------------------

The crypto policy definiton files have a simple syntax following an *INI* file
'key' = 'value' syntax with these particular features:

* Comments are indicated by '#' character. Everything on the line following the
    character is ignored.
  * Backslash '\' character followed immediately with the end-of-line character
    indicates line continuation. The following line is concatenated to the current
    line after the backslash and end-of-line characters are removed.
  * Value types can be either decimal integers, arbitrary strings, or lists of
    strings without whitespace characters separated by any number of whitespaces.

The allowed keys are:

* *mac*: List of allowed MAC algorithms
  * *ssh_group*: Optional; list of allowed groups or elliptic curves for key exchanges
    for use with the SSH protocol. If absent, the value is derived from *group*.
  * *group*: List of allowed groups or elliptic curves for key exchanges
    for use with other protocols
  * *hash*: List of allowed cryptographic hash (message digest) algorithms
  * *sign*: List of allowed signature algorithms
  * *tls_cipher*: Optional; list of allowed symmetric encryption algorithms (including the modes)
    for use with the TLS protocol. If absent, the value is derived from *cipher*.
  * *ssh_cipher*: Optional; list of allowed symmetric encryption algorithms (including the modes)
    for use with the SSH protocol. If absent, the value is derived from *cipher*.
  * *cipher*: List of allowed symmetric encryption algorithms (including the modes)
    for use with other protocols
  * *key_exchange*: List of allowed key exchange algorithms
  * *protocol*: List of allowed TLS and DTLS protocol versions (ignored by *OpenSSL*
    and *NSS* back ends)
  * *ike_protocol*: List of allowed IKE protocol versions
  * *min_tls_version*: Lowest allowed TLS protocol version (used only by *OpenSSL* a
    and *NSS* back ends)
  * *min_dtls_version*: Lowest allowed DTLS protocol version (used only by *NSS* back
    end)
  * *min_dh_size*: Integer value of minimum number of bits of parameters for *DH*
    key exchange
  * *min_dsa_size*: Integer value of minimum number of bits for *DSA* keys
  * *min_rsa_size*: Integer value of minimum number of bits for *RSA* keys
  * *sha1_in_certs*: Value of 1 if *SHA1* allowed in certificate signatures,
    0 otherwise (Applies to *GnuTLS* back end only.)
  * *sha1_in_dnssec*: Value of 1 if *SHA1* allowed in DNSSec protocol even if it is
    not present in the *hash* and *sign* lists, 0 otherwise (Applies to *BIND* back
    end only.)
  * *arbitrary_dh_groups*: Value of 1 if arbitrary group in
    *Diffie-Hellman* is allowed, 0 otherwise
  * *ssh_certs*: Value of 1 if *OpenSSH* certificate authentication is
     allowed, 0 otherwise
  * *ssh_etm*: Value of 1 if *OpenSSH* EtM (encrypt-then-mac) extension is
     allowed, 0 otherwise

The full policy definition files have suffix `.pol`, the policy module definition
files have suffix `.pmod`. The policy module files do not have to have values
set for all the keys listed above.

The lists as set in the base (full policy) are modified by the lists specified in the
module files in following way:

* *-*'list-item': The 'list-item' is removed from the list specified in the base
    policy.
  * *+*'list-item': The 'list-item' is inserted at the beginning of the list specified
    in the base policy. The inserts are done in the order of appearance in the
    policy module file so the actual order in the final list will be reversed.
  * 'list-item'*+*: The 'list-item' is appended to the end of the list specified
    in the base policy.

To completely override a list value in a module file just use 'list-items' without any
sign. Combining 'list-items' with and without signs in a single list value assignment is
not allowed however an existing list value can be modified in multiple further assignments.

Non-list key values in the policy module files are simply overriden.

The keys marked as *Optional* can be omitted in the policy definition
files. In that case, the values will be derived from the base
keys. Note that, this value propagation only applies to the policy
definition files. In the policy module files, each key that needs
modification must be explicitly specified.

*Policy file placement and naming:*

The policy files shipped in packages are placed in
`/usr/share/crypto-policies/policies` and the policy modules in
`/usr/share/crypto-policies/policies/modules`.

The locally configured policy files are placed in
`/etc/crypto-policies/policies` and the policy modules in
`/etc/crypto-policies/policies/modules`.

The policy and policy module files must have names in upper-case except
for the `.pol` and `.pmod` suffix as the update-crypto-policies command
always converts the policy name to upper-case before searching for
the policy on the filesystem.

COMMANDS
--------

*update-crypto-policies(8)*::
  This command manages the policies available to the various cryptographic
  back ends and allows the system administrator to change the active
  cryptographic policy level.

*fips-mode-setup(8)*::
  This command allows the system administrator to enable, or disable the
  system FIPS mode and also apply the *FIPS* cryptographic policy level
  which limits the allowed algorithms and protocols to these allowed by
  the FIPS 140-2 requirements.

NOTES
-----

*Exceptions*

* *Go-language* applications do not yet follow the system-wide policy.
* *GnuPG-2* application does not follow the system-wide policy.

In general only the data-in-transit is currently covered by the system-wide
policy.

If the system administrator changes the system-wide policy level with
the *update-crypto-policies(8)* command it is advisable to restart the
system as the individual back-end libraries read the configuration files
usually during their initialization. The changes in the policy level
thus take place in most cases only when the applications using the back-end
libraries are restarted.

*Removed cipher suites and protocols*

The following cipher suites and protocols are completely removed from the
core cryptographic libraries listed above:

* *DES*
* All export grade cipher suites
* *MD5* in signatures
* *SSLv2*
* *SSLv3*
* All *ECC* curves smaller than 224 bits
* All binary field *ECC* curves

*Cipher suites and protocols disabled in all policy levels*

The following ciphersuites and protocols are available but disabled in all
crypto policy levels. They can be enabled only by explicit configuration
of individual applications:

* *DH* with parameters < 1024 bits
* *RSA* with key size < 1024 bits
* *Camellia*
* *ARIA*
* *SEED*
* *IDEA*
* Integrity only ciphersuites
* *TLS* *CBC mode* ciphersuites using *SHA-384* HMAC
* *AES-CCM8*
* all *ECC* curves incompatible with *TLS 1.3*, including secp256k1
* *IKEv1*

*Notable irregularities in the individual configuration generators*

* *OpenSSL*: The minimum length of the keys and some other parameters
are enforced by the @SECLEVEL value which does not provide a fine
granularity. The list of *TLS* ciphers is not generated as an exact list
but by subtracting from all the supported ciphers for the enabled key
exchange methods. For that reason there is no way to disable a random cipher.
In particular all *AES-128* ciphers are disabled if the *AES-128-GCM* is not
present in the list; all *AES-256* ciphers are disabled if the *AES-256-GCM*
is not present. The *CBC* ciphers are disabled if there isn't *HMAC-SHA1*
in the hmac list and *AES-256-CBC* in the cipher list. To disable the *CCM*
ciphers both *AES-128-CCM* and *AES-256-CCM* must not be present in the cipher
list.

* *GnuTLS*: The minimum length of the keys and some other parameters
are enforced by min-verification-profile setting in the *GnuTLS* configuration
file which does not provide fine granularity.

* *OpenSSH*: *DH* group 1 is always disabled on server even if the policy
allows 1024 bit *DH* groups in general. The OpenSSH configuration option
HostKeyAlgorithms is set only for the *SSH* server as otherwise the
handling of the existing known hosts entries would be broken on client.

* *Libreswan*: The *key_exchange* parameter does not affect the generated
configuration. The use of regular *DH* or *ECDH* can be limited with appropriate
setting of the *group* parameter.

HISTORY
-------

The *ECDHE-GSS* and *DHE-GSS* algorithms are newly introduced and must be
specified in the base policy for the SSH GSSAPI key exchange methods
to be enabled. Previously the legacy SSH GSSAPI key exchange methods were
automatically enabled when the *SHA1* hash and *DH* parameters of at least
2048 bits were enabled.

Before the introduction of the *custom crypto policies* support it
was possible to have an completely arbitrary crypto policy created as
a set of arbitrary back-end config files in
`/usr/share/crypto-policies/<POLICYNAME>` directory. With the introduction
of the *custom crypto policies* it is still possible but there must
be an empty (possibly with any comment lines) `<POLICYNAME>.pol` file
in `/usr/share/crypto-policies/policies` so the `update-crypto-policies`
command can recognize the arbitrary custom policy.

FILES
-----
/etc/crypto-policies/back-ends::
	The individual cryptographical back-end configuration files.
	Usually linked to the configuration shipped in the crypto-policies
	package unless a configuration from `local.d` is added.

/etc/crypto-policies/config::
	The active crypto-policies level set on the system.

/etc/crypto-policies/local.d::
	Additional configuration shipped by other packages or created by
	the system administrator. The contents of the `<back-end>-file.config`
	is appended to the configuration from the policy back end as
	shipped in the crypto-policies package.

/usr/share/crypto-policies/policies::
	System policy definition files.

/usr/share/crypto-policies/policies/modules::
	System subpolicy module definition files.

/etc/crypto-policies/policies::
	Custom policy definition files as configured by the system
	administrator.

/etc/crypto-policies/policies/modules::
	Custom subpolicy module definition files as configured by the system
	administrator.

/usr/share/crypto-policies/<'POLICYNAME'>::
	Pre-generated back-end configurations for policy 'POLICYNAME'.

SEE ALSO
--------
update-crypto-policies(8), fips-mode-setup(8)

AUTHOR
------
Written by Tomáš Mráz.
07070100000007000081A4000003E800000064000000016005CA76000002B0000000000000000000000000000000000000003700000000fedora-crypto-policies-20210118.b21c811/default-config# This file should contain a single keyword, the crypto policy to
# be applied by default to applications. The available policies are 
# restricted to the following profiles.
#
# * LEGACY: Ensures maximum compatibility with legacy systems (64-bit
#   security).
#
# * DEFAULT: A reasonable default for today's standards (112-bit security).
#
# * FUTURE: A level that will provide security on a conservative level that is
#   believed to withstand any near-term future attacks (128-bit security).
#
# * FIPS: Policy that enables only FIPS 140-2 approved or allowed algorithms.
#
# After modifying this file, you need to run update-crypto-policies
# for the changes to propagate.
#
DEFAULT
07070100000008000041ED000003E800000064000000026005CA7600000000000000000000000000000000000000000000002C00000000fedora-crypto-policies-20210118.b21c811/doc07070100000009000081A4000003E800000064000000016005CA760000046B000000000000000000000000000000000000003400000000fedora-crypto-policies-20210118.b21c811/doc/DCO.txtDeveloper's Certificate of Origin 1.1

By making a contribution to this project, I certify that:

(a) The contribution was created in whole or in part by me and I
    have the right to submit it under the open source license
    indicated in the file; or

(b) The contribution is based upon previous work that, to the best
    of my knowledge, is covered under an appropriate open source
    license and I have the right under that license to submit that
    work with modifications, whether created in whole or in part
    by me, under the same open source license (unless I am
    permitted to submit under a different license), as indicated
    in the file; or

(c) The contribution was provided directly to me by some other
    person who certified (a), (b) or (c) and I have not modified
    it.

(d) I understand and agree that this project and the contribution
    are public and that a record of the contribution (including all
    personal information I submit with it, including my sign-off) is
    maintained indefinitely and may be redistributed consistent with
    this project or the open source license(s) involved.
0707010000000A000081ED000003E800000064000000016005CA76000003D1000000000000000000000000000000000000003C00000000fedora-crypto-policies-20210118.b21c811/fips-finish-install#!/bin/bash

set -e

system_fips=/etc/system-fips
dracut_cfg_d=/etc/dracut.conf.d
dracut_cfg=$dracut_cfg_d/40-fips.conf

is_ostree_system=0
if test -f /run/ostree-booted; then
    is_ostree_system=1
fi

if test x"$1" !=  x--complete ; then
	echo "Complete the instalation of FIPS modules."
	echo "usage: $0 --complete"
	exit 2
fi

if [ $(id -u) != 0 ]; then
	echo "You must be root to run $(basename $0)"
	exit 1
fi

umask 022

trap "rm -f $system_fips $dracut_cfg" ERR

echo "# FIPS module installation complete" >$system_fips

if test ! -d $dracut_cfg_d -o ! -d /boot -o "$is_ostree_system" = 1 ; then
	# No dracut configuration or boot directory present, do not try to modify it.
	# Also, on OSTree systems, we currently rely on the initrd already including
	# the FIPS module.
	exit 0
fi

cat >$dracut_cfg <<EOF
# turn on fips module

add_dracutmodules+=" fips "
EOF

echo "Kernel initramdisks are being regenerated. This might take some time."

dracut -f --regenerate-all
0707010000000B000081A4000003E800000064000000016005CA7600000628000000000000000000000000000000000000004200000000fedora-crypto-policies-20210118.b21c811/fips-finish-install.8.txt////
Copyright (C) 2018 Red Hat, Inc.

fips-finish-install(8)
======================
:doctype: manpage
:man source: fips-finish-install

NAME
----
fips-finish-install - complete the instalation of FIPS modules.

SYNOPSIS
--------
*fips-finish-install* --complete

DESCRIPTION
-----------
fips-finish-install(8) is used by the fips-mode-setup(8) command to
complete the installation of the system FIPS modules. The tool is not
supposed to be called directly by the system administrator, but it is
possible to do so.

The completion of the installation cannot be undone. The system has to
be reinstalled if the FIPS modules are not supposed to be installed
anymore.

[[options]]
OPTIONS
-------

The only recognized and mandatory option is:

--complete:   The command completes the FIPS module installation and
                calls 'dracut -f' to regenerate the initramfs.

FILES
-----
/etc/system-fips::
	The presence of the file indicates that the installation of FIPS
        modules was completed.

SEE ALSO
--------
fips-mode-setup(8)

AUTHOR
------
Written by Tomáš Mráz.
0707010000000C000081ED000003E800000064000000016005CA7600000F28000000000000000000000000000000000000003800000000fedora-crypto-policies-20210118.b21c811/fips-mode-setup#!/bin/bash

umask 022

usage=0
enable_fips=
check=0
boot_config=1
err_if_disabled=0
fips_install_complete=0
output_text=1

is_ostree_system=0
if test -f /run/ostree-booted; then
    is_ostree_system=1
fi

enable2txt () {
	case "$1" in
		0)
			echo "disabled"
			;;
		1)
			echo "enabled"
			;;
	esac
}

cond_echo () {
	if test "$output_text" != 0;then
		echo "$@"
	fi
}

while test $# -ge 1 ; do
	case "$1" in
		--enable)
			enable_fips=1
			;;
		--disable)
			enable_fips=0
			;;
		--check)
			check=1
			enable_fips=2
			;;
		--is-enabled)
			check=1
			enable_fips=2
			err_if_disabled=1
			output_text=0
			;;
		--no-bootcfg)
			boot_config=0
			;;
		*)
			usage=1
			;;
	esac
	shift
done

if test $usage = 1 -o x$enable_fips = x ; then
	echo "Check, enable, or disable the system FIPS mode."
	echo "usage: $0 --enable|--disable [--no-bootcfg]"
	echo "usage: $0 --check"
	echo "usage: $0 --is-enabled"
	exit 2
fi

# We don't handle the boot config on OSTree systems for now; it is assumed to be
# handled at a higher level. E.g. in Fedora CoreOS and RHEL CoreOS, it is
# intrinsically tied to the firstboot procedure.
if test "$is_ostree_system" = 1 && test "$enable_fips" = 1 && test "$boot_config" = 1; then
    cond_echo "Cannot perform boot config changes on OSTree systems (use --no-bootcfg)"
    exit 1
fi

if test -f /etc/system-fips ; then
	# On OSTree systems, /etc/system-fips in the real root marks completion.
	if test ! -d /boot -o "$is_ostree_system" = 1 -o ! -x /usr/bin/lsinitrd -o x"$(/usr/bin/lsinitrd -f etc/system-fips 2>/dev/null || test $? = 2 && echo y)" != x ; then
		fips_install_complete=1
	fi
fi

if test $check = 1 ; then
	test $fips_install_complete = 0 && cond_echo "Installation of FIPS modules is not completed."
	fips_enabled=$(cat /proc/sys/crypto/fips_enabled)
	cond_echo "FIPS mode is $(enable2txt $fips_enabled)."
	if test "$fips_enabled" = 1 ; then
		if test $fips_install_complete = 0 ; then
			cond_echo "Inconsistent state detected."
			exit 1
		fi
		current="$(cat /etc/crypto-policies/state/current)"
		if test "$(echo $current | cut -f 1 -d :)" != "FIPS" ; then
			cond_echo "The current crypto policy ($current) is not a FIPS policy."
		fi
	fi
	if test "$fips_enabled" != 1 && test "$err_if_disabled" = 1;then
		exit 2
	fi
	exit 0
fi

if [ $(id -u) != 0 ]; then
	echo "You must be root to run $(basename $0)"
	exit 1
fi

if test $enable_fips = 1 ; then
	if test $fips_install_complete = 0 ; then
		fips-finish-install --complete
		if test $? != 0 ; then
			echo "Installation of FIPS modules could not be completed."
			exit 1
		fi
	fi
	update-crypto-policies --no-reload --set FIPS 2>/dev/null
else
	update-crypto-policies --no-reload --set DEFAULT 2>/dev/null
fi

boot_device="$(df -P /boot | tail -1)"
echo "$boot_device" | grep -q ' /$' && boot_device='/' || boot_device=$(echo "$boot_device" | cut -d ' ' -f 1)

if test x"$boot_device" = x ; then
	echo "Boot device not identified, you have to configure the bootloader manually."
	boot_device_opt=" boot=UUID=<your-boot-device-uuid>"
	boot_config=0
else
        if test "$boot_device" = / ; then
            boot_device_opt=""
        else
            boot_device_opt=" boot=UUID=$(blkid -s UUID -o value $boot_device)"
        fi
fi

if test $boot_config=1 && test ! -x "$(command -v grubby)" ; then
	echo "The grubby command is missing, please configure the bootloader manually."
	boot_config=0
fi

echo "FIPS mode will be $(enable2txt $enable_fips)."

fipsopts="fips=$enable_fips$boot_device_opt"

if test $boot_config = 0 ; then
	echo "Now you need to configure the bootloader to add kernel options \"$fipsopts\""
	echo "and reboot the system for the setting to take effect."
else
	grubby --update-kernel=ALL --args="$fipsopts"
	if test x"$(uname -m)" = xs390x ; then
		zipl >/dev/null 2>&1
	fi
	echo "Please reboot the system for the setting to take effect."
fi

exit 0
0707010000000D000081A4000003E800000064000000016005CA76000007FF000000000000000000000000000000000000003E00000000fedora-crypto-policies-20210118.b21c811/fips-mode-setup.8.txt////
Copyright (C)2018 Red Hat, Inc.

fips-mode-setup(8)
==================
:doctype: manpage
:man source: fips-mode-setup

NAME
----
fips-mode-setup - Check, enable, or disable the system FIPS mode.

SYNOPSIS
--------
*fips-mode-setup* ['COMMAND']

DESCRIPTION
-----------
fips-mode-setup(8) is used to check and control the system FIPS mode.

When enabling the system FIPS mode the command completes the installation
of FIPS modules if needed by calling 'fips-finish-install' and changes the
system crypto policy to FIPS.

Then the command modifies the boot loader configuration to add
'fips=1' and 'boot=<boot-device>' options to the kernel command line.

When disabling the system FIPS mode the system crypto policy is switched
to DEFAULT and the kernel command line option 'fips=0' is set.

[[options]]
OPTIONS
-------

The following options are available in fips-mode-setup tool.

* --enable:     Enables the system FIPS mode.

* --disable:    Disables the system FIPS mode.

* --check:      Checks the system FIPS mode status.

* --is-enabled: Checks the system FIPS mode status and returns failure
                error code if disabled (2) or inconsistent (1).

* --no-bootcfg: The tool will not attempt to change the boot loader
                configuration and it just prints the options that need
                to be added to the kernel command line.

FILES
-----
/proc/sys/crypto/fips_enabled::
	The kernel FIPS mode flag.

SEE ALSO
--------
update-crypto-policies(8), fips-finish-install(8)

AUTHOR
------
Written by Tomáš Mráz.
0707010000000E000041ED000003E800000064000000036005CA7600000000000000000000000000000000000000000000003100000000fedora-crypto-policies-20210118.b21c811/policies0707010000000F000081A4000003E800000064000000016005CA7600000A52000000000000000000000000000000000000003D00000000fedora-crypto-policies-20210118.b21c811/policies/DEFAULT.pol# A reasonable default for today's standards. It should provide
# 112-bit security with the exception of SHA1 signatures in DNSSec
# SHA1 is also enabled in HMAC where collision attacks do not matter.

# MACs: all HMAC with SHA1 or better + all modern MACs (Poly1305 etc)
# Curves: all prime >= 255 bits (including Bernstein curves)
# Signature algorithms: with SHA-256 hash or better (no DSA)
# TLS Ciphers: >= 128-bit key, >= 128-bit block (AES, ChaCha20, including AES-CBC)
# non-TLS Ciphers: as TLS Ciphers with added Camellia
# key exchange: ECDHE, RSA, DHE (no DHE-DSS)
# DH params size: >= 2048
# RSA params size: >= 2048
# TLS protocols: TLS >= 1.2, DTLS >= 1.2

mac = AEAD HMAC-SHA2-256 HMAC-SHA1 UMAC-128 HMAC-SHA2-384 HMAC-SHA2-512

group = X25519 X448 SECP256R1 SECP384R1 SECP521R1 \
    FFDHE-2048 FFDHE-3072 FFDHE-4096 FFDHE-6144 FFDHE-8192

hash = SHA2-256 SHA2-384 SHA2-512 SHA3-256 SHA3-384 SHA3-512 SHA2-224

sign = ECDSA-SHA3-256 ECDSA-SHA2-256 ECDSA-SHA2-256-FIDO \
       ECDSA-SHA3-384 ECDSA-SHA2-384 \
       ECDSA-SHA3-512 ECDSA-SHA2-512 \
       EDDSA-ED25519 EDDSA-ED25519-FIDO EDDSA-ED448 \
       RSA-PSS-SHA3-256 RSA-PSS-SHA2-256 \
       RSA-PSS-SHA3-384 RSA-PSS-SHA2-384 \
       RSA-PSS-SHA3-512 RSA-PSS-SHA2-512 \
       RSA-PSS-RSAE-SHA3-256 RSA-PSS-RSAE-SHA2-256 \
       RSA-PSS-RSAE-SHA3-384 RSA-PSS-RSAE-SHA2-384 \
       RSA-PSS-RSAE-SHA3-512 RSA-PSS-RSAE-SHA2-512 \
       RSA-SHA3-256 RSA-SHA2-256 \
       RSA-SHA3-384 RSA-SHA2-384 \
       RSA-SHA3-512 RSA-SHA2-512 \
       ECDSA-SHA2-224 RSA-PSS-SHA2-224 RSA-SHA2-224

tls_cipher = AES-256-GCM AES-256-CCM CHACHA20-POLY1305 AES-256-CBC \
    AES-128-GCM AES-128-CCM AES-128-CBC

cipher = AES-256-GCM AES-256-CCM CHACHA20-POLY1305 CAMELLIA-256-GCM \
    AES-256-CTR AES-256-CBC CAMELLIA-256-CBC AES-128-GCM AES-128-CCM \
    CAMELLIA-128-GCM AES-128-CTR AES-128-CBC CAMELLIA-128-CBC

# CBC ciphers in SSH are considered vulnerable to plaintext recovery attacks
# and disabled in client OpenSSH 7.6 (2017) and server OpenSSH 6.7 (2014).
ssh_cipher = AES-256-GCM CHACHA20-POLY1305 AES-256-CTR AES-128-GCM AES-128-CTR

# 'RSA' is intentionally before DHE ciphersuites, as the DHE ciphersuites have
# interoperability issues in TLS.
key_exchange = ECDHE RSA DHE DHE-RSA PSK DHE-PSK ECDHE-PSK RSA-PSK ECDHE-GSS DHE-GSS

protocol = TLS1.3 TLS1.2 DTLS1.2
ike_protocol = IKEv2

min_tls_version = TLS1.2
min_dtls_version = DTLS1.2

# Parameter sizes
min_dh_size = 2048
min_dsa_size = 2048
min_rsa_size = 2048

# GnuTLS only for now
sha1_in_certs = 0

# SHA1 is still prevalent in DNSSec
sha1_in_dnssec = 1

arbitrary_dh_groups = 1
ssh_certs = 1
ssh_etm = 1
07070100000010000081A4000003E800000064000000016005CA760000018B000000000000000000000000000000000000003B00000000fedora-crypto-policies-20210118.b21c811/policies/EMPTY.pol# Just an empty policy for testing

mac =

group =

ssh_group =

hash =

sign =

tls_cipher =

ssh_cipher =

cipher =

key_exchange =

protocol =
ike_protocol =

min_tls_version = 0
min_dtls_version = 0

# Parameter sizes
min_dh_size = 0
min_dsa_size = 0
min_rsa_size = 0

# GnuTLS only for now
sha1_in_certs = 0

# For BIND
sha1_in_dnssec = 0

arbitrary_dh_groups = 0
ssh_certs = 0
ssh_etm = 0
07070100000011000081A4000003E800000064000000016005CA7600000869000000000000000000000000000000000000003A00000000fedora-crypto-policies-20210118.b21c811/policies/FIPS.pol# Only FIPS approved or allowed algorithms. It does not provide FIPS compliace
# by itself, the FIPS validated crypto modules must be properly installed
# and the machine must be booted into the FIPS mode.

# MACs: all HMAC with SHA1 or better
# Curves: all prime >= 256 bits
# Signature algorithms: with SHA224 hash or better (no DSA)
# TLS Ciphers: >= 128-bit key, >= 128-bit block (AES, including AES-CBC)
# non-TLS Ciphers: same
# key exchange: ECDHE, RSA, DHE (no DHE-DSS)
# DH params size: >= 2048
# RSA params size: >= 2048
# TLS protocols: TLS >= 1.2, DTLS >= 1.2

mac = AEAD HMAC-SHA2-256 HMAC-SHA1 HMAC-SHA2-384 HMAC-SHA2-512

group = SECP256R1 SECP384R1 SECP521R1 \
    FFDHE-2048 FFDHE-3072 FFDHE-4096 FFDHE-6144 FFDHE-8192

hash = SHA2-256 SHA2-384 SHA2-512 SHA2-224 SHA3-256 SHA3-384 SHA3-512

sign = ECDSA-SHA3-256 ECDSA-SHA2-256 \
       ECDSA-SHA3-384 ECDSA-SHA2-384 \
       ECDSA-SHA3-512 ECDSA-SHA2-512 \
       RSA-PSS-SHA3-256 RSA-PSS-SHA2-256 \
       RSA-PSS-SHA3-384 RSA-PSS-SHA2-384 \
       RSA-PSS-SHA3-512 RSA-PSS-SHA2-512 \
       RSA-PSS-RSAE-SHA3-256 RSA-PSS-RSAE-SHA2-256 \
       RSA-PSS-RSAE-SHA3-384 RSA-PSS-RSAE-SHA2-384 \
       RSA-PSS-RSAE-SHA3-512 RSA-PSS-RSAE-SHA2-512 \
       RSA-SHA3-256 RSA-SHA2-256 \
       RSA-SHA3-384 RSA-SHA2-384 \
       RSA-SHA3-512 RSA-SHA2-512 \
       ECDSA-SHA2-224 RSA-PSS-SHA2-224 RSA-SHA2-224

tls_cipher = AES-256-GCM AES-256-CCM AES-256-CBC \
    AES-128-GCM AES-128-CCM AES-128-CBC

cipher = AES-256-GCM AES-256-CCM AES-256-CTR AES-256-CBC \
    AES-128-GCM AES-128-CCM AES-128-CTR AES-128-CBC

# CBC ciphers in SSH are considered vulnerable to plaintext recovery attacks
# and disabled in client OpenSSH 7.6 (2017) and server OpenSSH 6.7 (2014).
ssh_cipher = AES-256-GCM AES-256-CTR AES-128-GCM AES-128-CTR

key_exchange = ECDHE DHE DHE-RSA PSK DHE-PSK ECDHE-PSK

protocol = TLS1.3 TLS1.2 DTLS1.2
ike_protocol = IKEv2

min_tls_version = TLS1.2
min_dtls_version = DTLS1.2

# Parameter sizes
min_dh_size = 2048
min_dsa_size = 2048
min_rsa_size = 2048

# GnuTLS only for now
sha1_in_certs = 0

# For BIND
sha1_in_dnssec = 0

arbitrary_dh_groups = 1
ssh_certs = 1
ssh_etm = 1
07070100000012000081A4000003E800000064000000016005CA76000009E7000000000000000000000000000000000000003C00000000fedora-crypto-policies-20210118.b21c811/policies/FUTURE.pol# A level that will provide security on a conservative level that is
# believed to withstand any near-term future attacks. And also provide
# some (not complete) preparation for post quantum encryption support
# in form of 256 bit symmetric encryption requirement.
# It provides at least an 128-bit security. This level may prevent
# communication with many used systems that provide weaker security levels
# (e.g., systems that use SHA-1 as signature algorithm).

# MACs: all HMAC with SHA256 or better + all modern MACs (Poly1305 etc)
# Curves: all prime >= 255 bits (including Bernstein curves)
# Signature algorithms: with SHA-256 hash or better (no DSA)
# TLS Ciphers: >= 256-bit key, >= 128-bit block, only Authenticated Encryption (AE) ciphers
# non-TLS Ciphers: same as TLS Ciphers with added non AE ciphers and Camellia
# key exchange: ECDHE, DHE (no DHE-DSS)
# DH params size: >= 3072
# RSA params size: >= 3072
# TLS protocols: TLS >= 1.2, DTLS >= 1.2

mac = AEAD HMAC-SHA2-256 UMAC-128 HMAC-SHA2-384 HMAC-SHA2-512

group = X25519 X448 SECP256R1 SECP384R1 SECP521R1 \
    FFDHE-3072 FFDHE-4096 FFDHE-6144 FFDHE-8192

hash = SHA2-256 SHA2-384 SHA2-512 SHA3-256 SHA3-384 SHA3-512

tls_cipher = AES-256-GCM AES-256-CCM CHACHA20-POLY1305

cipher = AES-256-GCM AES-256-CCM CHACHA20-POLY1305 CAMELLIA-256-GCM \
    AES-256-CTR AES-256-CBC CAMELLIA-256-CBC

key_exchange = ECDHE DHE DHE-RSA PSK DHE-PSK ECDHE-PSK ECDHE-GSS DHE-GSS

protocol = TLS1.3 TLS1.2 DTLS1.2
ike_protocol = IKEv2

min_tls_version = TLS1.2
min_dtls_version = DTLS1.2

# Parameter sizes
min_dh_size = 3072
min_dsa_size = 3072
min_rsa_size = 3072

# GnuTLS only for now
sha1_in_certs = 0

# For BIND
sha1_in_dnssec = 0

arbitrary_dh_groups = 1
ssh_certs = 1
ssh_etm = 1
07070100000013000081A4000003E800000064000000016005CA76000003B9000000000000000000000000000000000000003F00000000fedora-crypto-policies-20210118.b21c811/policies/GOST-ONLY.pol# Next generation GOST algorithms

mac = AEAD HMAC-STREEBOG-256 HMAC-STREEBOG-512 MAGMA-OMAC KUZNYECHIK-OMAC MAGMA-OMAC-ACPKM KUZNYECHIK-OMAC-ACPKM GOST28147-TC26Z-IMIT GOST28147-CPA-IMIT

group = GOST-GC256A GOST-GC256B GOST-GC256C GOST-GC256D GOST-GC512A GOST-GC512B GOST-GC512C

hash = GOSTR94 STREEBOG-256 STREEBOG-512

sign = GOSTR341001 GOSTR341012-256 GOSTR341012-512

tls_cipher = GOST28147-TC26Z-CNT GOST28147-CPA-CFB MAGMA-CTR-ACPKM KUZNYECHIK-CTR-ACPKM

cipher = GOST28147-TC26Z-CNT MAGMA-CTR-ACPKM KUZNYECHIK-CTR-ACPKM GOST28147-CPA-CFB GOST28147-CPB-CFB GOST28147-CPC-CFB GOST28147-CPD-CFB GOST28147-TC26Z-CFB

key_exchange = VKO-GOST-2001 VKO-GOST-2012 VKO-GOST-KDF

protocol = TLS1.3 TLS1.2 TLS1.1 TLS1.0

min_tls_version = TLS1.0

# Parameter sizes
# GOST ciphersuites don't use DH params. The value is set to fit SECLEVEL=2 for OpenSSL
min_dh_size = 2048
min_dsa_size = 2048
min_rsa_size = 2048

# GnuTLS only for now
sha1_in_certs = 0
07070100000014000081A4000003E800000064000000016005CA7600000BB9000000000000000000000000000000000000003C00000000fedora-crypto-policies-20210118.b21c811/policies/LEGACY.pol# Provides settings for ensuring maximum compatibility with legacy systems.
# This policy is less secure and intended to be a easy way to switch system
# to be compatible with older systems.
# It should provide at least 64-bit security and include RC4 and 3DES.

# MACs: all HMAC with SHA1 or better + all modern MACs (Poly1305 etc)
# Curves: all prime >= 255 bits (including Bernstein curves)
# Signature algorithms: with SHA-1 hash or better (DSA allowed)
# TLS Ciphers: all available > 112-bit key, >= 128-bit block (including RC4 and 3DES)
# non-TLS Ciphers: as TLS Ciphers with added Camellia
# key exchange: ECDHE, RSA, DHE
# DH params size: >= 1023
# RSA params size: >= 1023
# DSA params size: >= 1023
# TLS protocols: TLS >= 1.0 DTLS >= 1.0

mac = AEAD HMAC-SHA2-256 HMAC-SHA1 UMAC-128 HMAC-SHA2-384 HMAC-SHA2-512

group = X25519 X448 SECP256R1 SECP384R1 SECP521R1 \
    FFDHE-2048 FFDHE-3072 FFDHE-4096 FFDHE-6144 FFDHE-8192 FFDHE-1536

ssh_group = X25519 X448 SECP256R1 SECP384R1 SECP521R1 \
    FFDHE-2048 FFDHE-3072 FFDHE-4096 FFDHE-6144 FFDHE-8192 FFDHE-1536 FFDHE-1024

hash = SHA2-256 SHA2-384 SHA2-512 SHA3-256 SHA3-384 SHA3-512 SHA2-224 SHA1

tls_cipher = AES-256-GCM AES-256-CCM CHACHA20-POLY1305 AES-256-CBC \
    AES-128-GCM AES-128-CCM AES-128-CBC 3DES-CBC RC4-128

ssh_cipher = AES-256-GCM CHACHA20-POLY1305 AES-256-CTR AES-256-CBC \
    AES-128-GCM AES-128-CTR AES-128-CBC 3DES-CBC RC4-128

# 'RSA' is intentionally before DHE ciphersuites, as the DHE ciphersuites have
# interoperability issues in TLS.
key_exchange = ECDHE RSA DHE DHE-RSA DHE-DSS PSK DHE-PSK ECDHE-PSK RSA-PSK ECDHE-GSS DHE-GSS

protocol = TLS1.3 TLS1.2 TLS1.1 TLS1.0 DTLS1.2 DTLS1.0
ike_protocol = IKEv2

min_tls_version = TLS1.0
min_dtls_version = DTLS1.0

# Parameter sizes
min_dh_size = 1023
min_dsa_size = 1023
min_rsa_size = 1023

# GnuTLS only for now
sha1_in_certs = 1

# SHA1 is still prevalent in DNSSec
sha1_in_dnssec = 1

arbitrary_dh_groups = 1
ssh_certs = 1
ssh_etm = 1
070701000000150000A1FF000003E80000006400000001601C4A380000000B000000000000000000000000000000000000003A00000000fedora-crypto-policies-20210118.b21c811/policies/NEXT.polDEFAULT.pol07070100000016000041ED000003E800000064000000026005CA7600000000000000000000000000000000000000000000003900000000fedora-crypto-policies-20210118.b21c811/policies/modules07070100000017000081A4000003E800000064000000016005CA7600000131000000000000000000000000000000000000004900000000fedora-crypto-policies-20210118.b21c811/policies/modules/AD-SUPPORT.pmod# AD-SUPPORT policy module is intended to be used in Active Directory
# environments where either accounts or trusted domain objects were not yet
# migrated to AES or future encryption types. Active Directory implicitly
# requires RC4 encryption in Kerberos by default.
cipher = RC4-128+

mac = HMAC-MD5+
07070100000018000081A4000003E800000064000000016005CA76000000DC000000000000000000000000000000000000004900000000fedora-crypto-policies-20210118.b21c811/policies/modules/ECDHE-ONLY.pmod# This is example of policy module enforcing ECDHE and ECDHE with PSK
# key exchanges

key_exchange = ECDHE ECDHE-PSK
group = -FFDHE-1536 -FFDHE-2048 -FFDHE-3072 -FFDHE-4096 -FFDHE-6144 \
        -FFDHE-8192 -FFDHE-1024
07070100000019000081A4000003E800000064000000016005CA76000001BA000000000000000000000000000000000000004700000000fedora-crypto-policies-20210118.b21c811/policies/modules/FEDORA32.pmod# If this policy module is applied to the DEFAULT policy it provides
# the same policy as in the Fedora 32 DEFAULT policy

# DH params size: >= 1023
# SHA1 enabled in signatures
# TLS protocols: TLS >= 1.0 DTLS >= 1.0

ssh_group = FFDHE-1536+ FFDHE-1024+

hash = SHA1+

sign = ECDSA-SHA1+ RSA-PSS-SHA1+ RSA-SHA1+

protocol = TLS1.1+ TLS1.0+ DTLS1.0+

min_tls_version = TLS1.0
min_dtls_version = DTLS1.0

min_dh_size = 1023

sha1_in_certs = 1
0707010000001A000081A4000003E800000064000000016005CA7600000308000000000000000000000000000000000000004300000000fedora-crypto-policies-20210118.b21c811/policies/modules/GOST.pmod# This is example policy, the algorithm names might differ in reality
# Add GOST algorithms.

mac = +HMAC-STREEBOG-256 +HMAC-STREEBOG-512 +MAGMA-OMAC +KUZNYECHIK-OMAC +MAGMA-OMAC-ACPKM +KUZNYECHIK-OMAC-ACPKM +GOST28147-TC26Z-IMIT +GOST28147-CPA-IMIT +AEAD

group = +GOST-GC256A +GOST-GC256B +GOST-GC256C +GOST-GC256D +GOST-GC512A +GOST-GC512B +GOST-GC512C

hash = +STREEBOG-256 +STREEBOG-512 GOSTR94+

sign = +GOSTR341012-256 +GOSTR341012-512 GOSTR341001+

tls_cipher = +GOST28147-TC26Z-CNT +GOST28147-CPA-CFB +MAGMA-CTR-ACPKM +KUZNYECHIK-CTR-ACPKM

cipher = +GOST28147-TC26Z-CNT +MAGMA-CTR-ACPKM +KUZNYECHIK-CTR-ACPKM +GOST28147-CPA-CFB +GOST28147-CPB-CFB +GOST28147-CPC-CFB +GOST28147-CPD-CFB +GOST28147-TC26Z-CFB

key_exchange = +VKO-GOST-2001 +VKO-GOST-2012 +VKO-GOST-KDF
0707010000001B000081A4000003E800000064000000016005CA76000000F6000000000000000000000000000000000000004A00000000fedora-crypto-policies-20210118.b21c811/policies/modules/NO-CAMELLIA.pmod# This is example policy dropping the Camellia support altogether

tls_cipher = -CAMELLIA-256-GCM -CAMELLIA-256-CBC -CAMELLIA-128-GCM \
    -CAMELLIA-128-CBC

cipher = -CAMELLIA-256-GCM -CAMELLIA-256-CBC -CAMELLIA-128-GCM \
    -CAMELLIA-128-CBC
0707010000001C000081A4000003E800000064000000016005CA7600000096000000000000000000000000000000000000004600000000fedora-crypto-policies-20210118.b21c811/policies/modules/NO-SHA1.pmod# This is example subpolicy dropping the SHA1 hash and signature support

hash = -SHA1

sign = -RSA-PSS-SHA1 -RSA-SHA1 -ECDSA-SHA1

sha1_in_certs = 0
0707010000001D000081A4000003E800000064000000016005CA7600000340000000000000000000000000000000000000004300000000fedora-crypto-policies-20210118.b21c811/policies/modules/OSPP.pmod# Restrict FIPS policy for the Common Criteria OSPP profile.

# Hashes: only SHA1, SHA2-256, SHA2-384, and SHA2-512
# MACs: HMAC with only SHA1, SHA2-256, SHA2-384, and SHA2-512
# Curves: only P-256, P-384, and P-521
# SSH ciphers: only AES in CTR and GCM modes
# TLS ciphers: only AES in CBC and GCM modes
# SSH MACs: only hmac-sha1, hmac-sha1-96, hmac-sha2-256, hmac-sha2-512
# SSH key exchange: only diffie-hellman-group14-sha1, ecdh-sha2-nistp256,
#  ecdh-sha2-nistp384, ecdh-sha2-nistp521
# TLS protocols: TLS = 1.2, DTLS = 1.2

hash = -SHA2-224 -SHA3-256 -SHA3-384 -SHA3-512

ssh_group = -FFDHE-4096 -FFDHE-8192

cipher = -AES-256-CTR -AES-128-CTR -AES-256-CCM -AES-128-CCM

ssh_cipher = -AES-256-CCM -AES-128-CCM

tls_cipher = -AES-256-CCM -AES-128-CCM

ssh_certs = 0
ssh_etm = 0

protocol = -TLS1.3

arbitrary_dh_groups = 0
0707010000001E000081A4000003E800000064000000016005CA7600000087000000000000000000000000000000000000004300000000fedora-crypto-policies-20210118.b21c811/policies/modules/SHA1.pmod# This policy module adds SHA1 hash and signature support

hash = SHA1+

sign = ECDSA-SHA1+ RSA-PSS-SHA1+ RSA-SHA1+

sha1_in_certs = 1
0707010000001F000081A4000003E800000064000000016005CA760000042A000000000000000000000000000000000000003100000000fedora-crypto-policies-20210118.b21c811/pylintrc[MASTER]
# Pickle collected data for later comparisons.
persistent=no

# Use multiple processes to speed up Pylint.
jobs=0

# Ignore external repository for krb5 tests
ignore=krb5_conf.py,principals.py

[MESSAGES CONTROL]

enable=
    all,
    python3

disable=
    I,
    fixme,
    missing-docstring,
    too-many-arguments,
    too-many-branches,
    too-many-locals,
    too-many-statements,
    invalid-name,
    line-too-long,
    no-absolute-import,
    mixed-indentation,
    bad-indentation,
    bad-continuation,

[REPORTS]

# Set the output format. Available formats are text, parseable, colorized, msvs
# (visual studio) and html. You can also give a reporter class, eg
# mypackage.mymodule.MyReporterClass.
output-format=colorized

# Tells whether to display a full report or only the messages
reports=no

# Template used to display messages. This is a python new-style format string
# used to format the message information. See doc for all details
msg-template='{path}:{line}: [{msg_id}({symbol}), {obj}] {msg})'

# Disable evaluation score
score=no
07070100000020000041ED000003E800000064000000046005CA7600000000000000000000000000000000000000000000002F00000000fedora-crypto-policies-20210118.b21c811/python07070100000021000081ED000003E800000064000000016005CA760000106D000000000000000000000000000000000000004800000000fedora-crypto-policies-20210118.b21c811/python/build-crypto-policies.py#!/usr/bin/python3

# SPDX-License-Identifier: LGPL-2.1-or-later

import sys
import argparse
import os

import cryptopolicies
from cryptopolicies.cryptopolicies import eprint

import policygenerators

RELOAD_CMD_NAME = 'reload-cmds.sh'

def parse_args():
	"Parse the command line"
	parser = argparse.ArgumentParser(allow_abbrev=False)
	parser.add_argument('--flat', action='store_true',
		help='put all the generated files in a single directory')
	parser.add_argument('--test', action='store_true',
		help='compare the generated config file with the existing one')
	parser.add_argument('--policy', type=str, metavar='POLICY',
		help='generate the specified policy only')
	parser.add_argument('--reloadcmds', action='store_true',
		help='also save reload cmds into reload-cmds.sh script in output directory')
	parser.add_argument('policydir',
		help='a directory with base policy definition files (*.pol)')
	parser.add_argument('outputdir',
		help='a target directory with generated config files')
	return parser.parse_args()

def save_config(cmdline, policy_name, config_name, config):
	if cmdline.flat:
		path = os.path.join(cmdline.outputdir, '{}-{}.txt'.format(policy_name, config_name))
	else:
		dirpath = os.path.join(cmdline.outputdir, policy_name)
		if not os.path.isdir(dirpath):
			try:
				os.mkdir(dirpath)
			except OSError:
				eprint('Cannot create directory for policy {}'.format(policy_name))
				return False
		path = os.path.join(dirpath, config_name + '.txt')

if cmdline.test:
		try:
			with open(path, mode='r') as f:
				old_config = f.read()
			if old_config != config:
				eprint('Config for {} for policy {} differs from the existing one'.format(config_name, policy_name))
				return False
			return True
		except FileNotFoundError:
			pass
		except OSError:
			eprint('Error reading generated file {}'.format(path))
			return False

print('Saving config for {} for policy {}'.format(config_name, policy_name))
	with open(path, mode='w') as f:
		f.write(config)
	print()
	return True

def build_policy(cmdline, policy_name, subpolicy_names=None):
	err = 0
	if subpolicy_names is None:
		subpolicy_names = []
	cp = cryptopolicies.CryptoPolicy(cmdline.policydir)

try:
		cp.load_policy(policy_name)
		cp.load_subpolicies(subpolicy_names)
	except ValueError as e:
		eprint('Error: ' + str(e))
		return 1

if cp.errors:
		eprint('Errors found in policy ' + policy_name)
		return 2

cp.finalize()

generators = [g for g in dir(policygenerators) if 'Generator' in g]

for g in generators:
		cls = policygenerators.__dict__[g]
		gen = cls()
		config = gen.generate_config(cp)

if policy_name == 'EMPTY' or policy_name == 'GOST-ONLY' or gen.test_config(config):
			try:
				name = ':'.join([policy_name, *subpolicy_names])
				if not save_config(cmdline, name, gen.CONFIG_NAME, config):
					err = 5
			except OSError:
				eprint('Error saving config for ' + gen.CONFIG_NAME)
				eprint('Keeping original configuration')
				err = 4
		else:
			eprint('Error testing config for ' + gen.CONFIG_NAME)
			err = 3
	return err

def save_reload_cmds(cmdline):
	err = 0

generators = [g for g in dir(policygenerators) if 'Generator' in g]

path = os.path.join(cmdline.outputdir, RELOAD_CMD_NAME)
	try:
		with open(path, mode='w') as f:
			for g in generators:
				cls = policygenerators.__dict__[g]
				f.write(cls.RELOAD_CMD)
	except OSError:
		eprint('Error saving reload cmds')
		err = 6
	return err

def main():
	"The actual command implementation"
	cmdline = parse_args()
	err = 0

if cmdline.policy:
		(policy_name, *subpolicy_names) = filter(None, cmdline.policy.upper().split(':'))
		err = build_policy(cmdline, policy_name, subpolicy_names)
	else:
		with os.scandir(cmdline.policydir) as sd:
			for i in sd:
				if not i.name.startswith('.') and i.is_file(follow_symlinks=False):
					(policy_name, ext) = os.path.splitext(i.name)
					if ext == '.pol':
						err = build_policy(cmdline, policy_name)
						if err:
							break

if not err and cmdline.reloadcmds:
		err = save_reload_cmds(cmdline)

sys.exit(err)

# Entry point
if __name__ == "__main__":
        main()
07070100000022000041ED000003E800000064000000026005CA7600000000000000000000000000000000000000000000003E00000000fedora-crypto-policies-20210118.b21c811/python/cryptopolicies07070100000023000081A4000003E800000064000000016005CA76000000B8000000000000000000000000000000000000004A00000000fedora-crypto-policies-20210118.b21c811/python/cryptopolicies/__init__.py# SPDX-License-Identifier: LGPL-2.1-or-later

from .cryptopolicies import CryptoPolicy
07070100000024000081A4000003E800000064000000016005CA760000218A000000000000000000000000000000000000005000000000fedora-crypto-policies-20210118.b21c811/python/cryptopolicies/cryptopolicies.py# SPDX-License-Identifier: LGPL-2.1-or-later

import sys
import os
import os.path
import re
import copy

def eprint(*args, **kwargs):
	print(*args, file=sys.stderr, **kwargs)

class CryptoPolicy:
	string_re = re.compile(r'^(\w|-|\.)+$', re.ASCII)

ALL_MAC = ['AEAD', 'UMAC-128', 'HMAC-SHA1', 'HMAC-SHA2-256',
		'HMAC-SHA2-384', 'HMAC-SHA2-512', 'UMAC-64', 'HMAC-MD5',
		'HMAC-STREEBOG-256', 'HMAC-STREEBOG-512',
		'GOST28147-CPA-IMIT', 'GOST28147-TC26Z-IMIT',
		'MAGMA-OMAC', 'KUZNYECHIK-OMAC',
		'MAGMA-OMAC-ACPKM', 'KUZNYECHIK-OMAC-ACPKM']
	ALL_HASH = ['SHA2-256', 'SHA2-384', 'SHA2-512', 'SHA3-256',
		'SHA3-384', 'SHA3-512', 'SHA2-224', 'SHA1', 'MD5',
		'STREEBOG-256', 'STREEBOG-512', 'GOSTR94']
# we disable curves <= 256 bits by default in Fedora
	ALL_GROUP = ['X25519', 'SECP256R1', 'SECP384R1', 'SECP521R1', 'X448',
		'FFDHE-1536', 'FFDHE-2048', 'FFDHE-3072', 'FFDHE-4096',
		'FFDHE-6144', 'FFDHE-8192', 'FFDHE-1024',
		'GOST-GC256A', 'GOST-GC256B', 'GOST-GC256C', 'GOST-GC256D',
		'GOST-GC512A', 'GOST-GC512B', 'GOST-GC512C']

ALL_SSH_GROUP = ALL_GROUP

ALL_SIGN = ['RSA-MD5', 'RSA-SHA1', 'DSA-SHA1', 'ECDSA-SHA1',
		'RSA-SHA2-224', 'DSA-SHA2-224', 'ECDSA-SHA2-224',
		'RSA-SHA2-256', 'DSA-SHA2-256', 'ECDSA-SHA2-256', 'ECDSA-SHA2-256-FIDO',
		'RSA-SHA2-384', 'DSA-SHA2-384', 'ECDSA-SHA2-384',
		'RSA-SHA2-512', 'DSA-SHA2-512', 'ECDSA-SHA2-512',
		'RSA-SHA3-256', 'DSA-SHA3-256', 'ECDSA-SHA3-256',
		'RSA-SHA3-384', 'DSA-SHA3-384', 'ECDSA-SHA3-384',
		'RSA-SHA3-512', 'DSA-SHA3-512', 'ECDSA-SHA3-512',
		'EDDSA-ED25519', 'EDDSA-ED25519-FIDO', 'EDDSA-ED448',
		'RSA-PSS-SHA1', 'RSA-PSS-SHA2-224', 'RSA-PSS-SHA2-256',
		'RSA-PSS-SHA2-384', 'RSA-PSS-SHA2-512', 'RSA-PSS-RSAE-SHA1',
		'RSA-PSS-RSAE-SHA2-224', 'RSA-PSS-RSAE-SHA2-256',
		'RSA-PSS-RSAE-SHA2-384', 'RSA-PSS-RSAE-SHA2-512',
		'RSA-PSS-SHA3-256', 'RSA-PSS-SHA3-384', 'RSA-PSS-SHA3-512',
		'RSA-PSS-RSAE-SHA3-256', 'RSA-PSS-RSAE-SHA3-384', 'RSA-PSS-RSAE-SHA3-512',
		'GOSTR341012-512', 'GOSTR341012-256', 'GOSTR341001']

ALL_CIPHER = ['AES-256-GCM', 'AES-256-CCM',
		'AES-192-GCM', 'AES-192-CCM',
		'AES-128-GCM', 'AES-128-CCM',
		'CHACHA20-POLY1305', 'CAMELLIA-256-GCM',
		'CAMELLIA-128-GCM', 'AES-256-CTR', 'AES-256-CBC',
		'AES-192-CTR', 'AES-192-CBC',
		'AES-128-CTR', 'AES-128-CBC', 'CAMELLIA-256-CBC',
		'CAMELLIA-128-CBC', '3DES-CBC', 'DES-CBC', 'RC4-40',
		'RC4-128', 'DES40-CBC', 'RC2-CBC', 'IDEA-CBC', 'SEED-CBC',
		'GOST28147-TC26Z-CFB', 'GOST28147-CPA-CFB', 'GOST28147-CPB-CFB',
		'GOST28147-CPC-CFB', 'GOST28147-CPD-CFB', 'GOST28147-TC26Z-CNT',
		'MAGMA-CTR-ACPKM', 'KUZNYECHIK-CTR-ACPKM',
		'NULL']

ALL_TLS_CIPHER = ALL_CIPHER

ALL_SSH_CIPHER = ALL_CIPHER

ALL_KEY_EXCHANGE = ['PSK', 'DHE-PSK', 'ECDHE-PSK', 'RSA-PSK', 'ECDHE',
		'RSA', 'DHE', 'DHE-RSA', 'DHE-DSS', 'EXPORT', 'ANON', 'DH',
		'ECDH', 'VKO-GOST-2001', 'VKO-GOST-2012', 'VKO-GOST-KDF',
		'DHE-GSS', 'ECDHE-GSS']

ALL_PROTOCOL = ['SSL2.0', 'SSL3.0', 'TLS1.0', 'TLS1.1', 'TLS1.2',
		'TLS1.3', 'DTLS1.0', 'DTLS1.2']

ALL_IKE_PROTOCOL = ['IKEv1', 'IKEv2']

ALL_PROPS = {'hash':ALL_HASH, 'mac':ALL_MAC, 'group':ALL_GROUP,
		'sign':ALL_SIGN, 'tls_cipher':ALL_TLS_CIPHER,
		'cipher':ALL_CIPHER, 'key_exchange':ALL_KEY_EXCHANGE,
		'protocol':ALL_PROTOCOL, 'ike_protocol':ALL_IKE_PROTOCOL,
		'ssh_cipher':ALL_SSH_CIPHER, 'ssh_group':ALL_SSH_GROUP}

DEFAULT_PROPS = {'hash':[], 'mac':[], 'group':[],
			 'sign':[], 'tls_cipher':[], 'cipher':[],
			 'key_exchange':[], 'protocol':[],
			 'ike_protocol':[],
			 'min_tls_version': '', 'min_dtls_version':'',
			 'min_dh_size': 0, 'min_rsa_size': 0,
			 'min_dsa_size': 0, 'sha1_in_certs': 0,
			 'sha1_in_dnssec': 0,
			 'arbitrary_dh_groups': 0,
			 'ssh_cipher': [], 'ssh_group': [],
			 'ssh_certs': 0, 'ssh_etm': 0}

DERIVED_PROPS = {'tls_cipher':'cipher', 'ssh_cipher':'cipher',
			 'ssh_group':'group'}

CONFIG_DIR = '/etc/crypto-policies'

SHARE_DIR = '/usr/share/crypto-policies'

def __init__(self, policydir=None):
		self.props = {}
		self.inverted_props = {}
		self.errors = 0
		self.policydir = policydir
		self.policyname = ''

def lookup_policy(self, policyname, subpolicy):
		if self.policydir:
			pdir = self.policydir
		else:
			pdir = 'policies'
		if subpolicy:
			pdir = os.path.join(pdir, 'modules')
			suffix = '.pmod'
		else:
			suffix = '.pol'

fname = policyname + suffix
		if os.access(fname, os.R_OK):
			return fname

path = os.path.join(pdir, fname)
		if os.access(path, os.R_OK):
			return path

cpath = os.path.join(self.CONFIG_DIR, path)
		if os.access(cpath, os.R_OK):
			return cpath

spath = os.path.join(self.SHARE_DIR, path)
		if os.access(spath, os.R_OK):
			return spath

raise ValueError('Unknown policy: ' + policyname)

@classmethod
	def parse_list(cls, name, value, orig):
		l = value.split()
		# clear the original list if value is empty
		if not l:
			orig.clear()
			return orig
		# syntax check first
		lset = -1
		for item in l:
			ins = 0
			app = 0
			rem = 0
			if item[:1] == '-':
				rem = 1
				item = item[1:]
			if item[:1] == '+':
				ins = 1
				item = item[1:]
			if item[-1:] == '+':
				app = 1
				item = item[:-1]
			if rem + ins + app > 1:
				raise ValueError('multiple operations for list item \'%s\'' % item)
			if not cls.string_re.match(item):
				raise ValueError('invalid list item \'%s\'' % item)
			if item not in cls.ALL_PROPS[name]:
				raise ValueError('unknown list item \'%s\'' % item)
			if rem + ins + app > 0:
				if lset == 1:
					raise ValueError('cannot initialize list and modify it at once')
				lset = 0
			else:
				if lset == 0:
					raise ValueError('cannot initialize list and modify it at once')
				lset = 1
		# now do the actual changes
		if lset:
			orig.clear()
		for item in l:
			ins = 0
			app = 0
			rem = 0
			if item[:1] == '-':
			    rem = 1
			    item = item[1:]
			if item[:1] == '+':
			    ins = 1
			    item = item[1:]
			if item[-1:] == '+':
			    app = 1
			    item = item[:-1]

if ins:
				try:
					orig.remove(item)
				except ValueError:
					pass
				orig.insert(0, item)
			elif rem:
				try:
					orig.remove(item)
				except ValueError:
					pass
			elif item not in orig:
				# append is the default
				orig.append(item)
		return orig

@classmethod
	def parse_str(cls, value):
		s = value.strip()
		if not cls.string_re.match(s):
			raise ValueError('invalid string \'%s\'' % s)
		return s

@staticmethod
	def parse_int(value):
		i = int(value.strip())
		return i

def parse(self, f, subpolicy):
		prevline = ''
		for line in f:
			if line.endswith('\\\n'):
				prevline += line[:-2].split('#', 1)[0]
				continue
			line = prevline + line.split('#', 1)[0]
			prevline = ''
			line = line.strip()
			if not line:
				continue
			try:
				(name, value) = line.split('=', 1)
			except ValueError:
				eprint('Syntax error on line: %s' % line)

name = name.strip()
			if not name in self.DEFAULT_PROPS:
				eprint('Unknown policy property: %s' % name)
				self.errors += 1
				continue
			prop = self.props.get(name, copy.copy(self.DEFAULT_PROPS[name]))
			try:
				if isinstance(prop, list):
					prop = self.parse_list(name, value, prop)
				elif isinstance(prop, str):
					prop = self.parse_str(value)
				elif isinstance(prop, int):
					prop = self.parse_int(value)
				self.props[name] = prop
			except ValueError as e:
				eprint('Bad value of policy property: %s - %s' % (name, e))
				self.errors += 1
		# resolve property derivation if this is not a subpolicy
		if not subpolicy:
			for name, base in self.DERIVED_PROPS.items():
				if base in self.props:
					self.props.setdefault(name, copy.copy(self.props[base]))
		# assign any missing properties to the default
		for name, default in self.DEFAULT_PROPS.items():
			self.props.setdefault(name, copy.copy(default))

def load_policy(self, policyname, subpolicy=False):
		fname = self.lookup_policy(policyname, subpolicy)

if self.policyname:
			self.policyname += ':'
		self.policyname += policyname

with open(fname, "r") as f:
			self.parse(f, subpolicy)

def load_subpolicies(self, policylist):
		for p in policylist:
			self.load_policy(p, True)

def finalize(self):
		self.inverted_props = {}
		for prop in self.ALL_PROPS:
			self.inverted_props[prop] = [s for s in self.ALL_PROPS[prop]
				if s not in self.props[prop]]

def __str__(self):
		s = '# Current runtime policy dump\n# {}\n'.format(self.policyname)
		for name, value in sorted(self.props.items()):
			if isinstance(value, list):
				value = ' '.join(value)
			s += '{} = {}\n'.format(name, value)
		return s
07070100000025000041ED000003E800000064000000026005CA7600000000000000000000000000000000000000000000004000000000fedora-crypto-policies-20210118.b21c811/python/policygenerators07070100000026000081A4000003E800000064000000016005CA7600000229000000000000000000000000000000000000004C00000000fedora-crypto-policies-20210118.b21c811/python/policygenerators/__init__.py# SPDX-License-Identifier: LGPL-2.1-or-later

from .bind import BindGenerator
from .gnutls import GnuTLSGenerator
from .java import JavaGenerator
from .krb5 import KRB5Generator
from .libreswan import LibreswanGenerator
from .libssh import LibsshGenerator
from .nss import NSSGenerator
from .openssh import OpenSSHClientGenerator
from .openssh import OpenSSHServerGenerator
from .openssl import OpenSSLConfigGenerator
from .openssl import OpenSSLGenerator
07070100000027000081A4000003E800000064000000016005CA760000078A000000000000000000000000000000000000004800000000fedora-crypto-policies-20210118.b21c811/python/policygenerators/bind.py# SPDX-License-Identifier: LGPL-2.1-or-later

from subprocess import check_output, CalledProcessError
from tempfile import mkstemp
import os

from .configgenerator import ConfigGenerator

class BindGenerator(ConfigGenerator):
	CONFIG_NAME = 'bind'

RELOAD_CMD = 'systemctl try-reload-or-restart bind.service 2>/dev/null || :\n'

sign_not_map = {
		'RSA-MD5':'RSAMD5',
		'DSA-SHA1':'DSA',
		'ECDSA-SHA1':'',
		'RSA-SHA1':'RSASHA1;\nNSEC3RSASHA1'
	}

hash_not_map = {
		'MD5':'',
		'SHA1':'SHA-1',
		'GOSTR94':'GOST',
		'SHA2-256':'SHA-256',
		'SHA2-384':'SHA-384'
	}

@classmethod
	def generate_config(cls, policy):
		ip = policy.inverted_props
		sep = ';\n'
		local_sign_not_map = dict(cls.sign_not_map)
		local_hash_not_map = dict(cls.hash_not_map)
		if policy.props['sha1_in_dnssec'] != 0:
			del local_sign_not_map['ECDSA-SHA1']
			del local_sign_not_map['RSA-SHA1']
			del local_hash_not_map['SHA1']

cfg = 'disable-algorithms "." {\n'
		s = ''
		for i in ip['sign']:
			try:
				s = cls.append(s, local_sign_not_map[i], sep)
			except KeyError:
				pass
		cfg += cls.append(s, '}', sep)

cfg = cls.append(cfg, 'disable-ds-digests "." {\n', sep)
		s = ''
		for i in ip['hash']:
			try:
				s = cls.append(s, local_hash_not_map[i], sep)
			except KeyError:
				pass
		cfg += cls.append(s, '};\n', sep)

return cfg

@classmethod
	def test_config(cls, config):
		fd, path = mkstemp()

try:
			with os.fdopen(fd, 'w') as f:
				f.write('options {\n')
				f.write(config)
				f.write('\n};\n')
			try:
				_output = check_output(["/usr/sbin/named-checkconf", path])
			except CalledProcessError:
				cls.eprint("There is an error in bind generated policy")
				cls.eprint("Policy:\n%s" % config)
				return False
			except OSError:
				# Ignore missing check command
				pass
		finally:
			os.unlink(path)

return True
07070100000028000081A4000003E800000064000000016005CA7600000190000000000000000000000000000000000000005300000000fedora-crypto-policies-20210118.b21c811/python/policygenerators/configgenerator.py# SPDX-License-Identifier: LGPL-2.1-or-later

import sys

class ConfigGenerator:
	RELOAD_CMD = ''

@staticmethod
	def append(s, val, sep=':'):
		if s:
			if val:
				return s + sep + val

return s

return val

@staticmethod
	def eprint(*args, **kwargs):
		print(*args, file=sys.stderr, **kwargs)
07070100000029000081A4000003E800000064000000016005CA7600001E78000000000000000000000000000000000000004A00000000fedora-crypto-policies-20210118.b21c811/python/policygenerators/gnutls.py# SPDX-License-Identifier: LGPL-2.1-or-later

# Copyright (c) 2019 Red Hat, Inc.
# Copyright (c) 2019 Tomáš Mráz <tmraz@fedoraproject.org>
#
# This generator works for GnuTLS 3.6.12 or later.

from subprocess import call, CalledProcessError
from tempfile import mkstemp

import os

from .configgenerator import ConfigGenerator

class GnuTLSGenerator(ConfigGenerator):
	CONFIG_NAME = 'gnutls'

mac_not_map = {
		'AEAD':'AEAD',
		'HMAC-SHA1':'SHA1',
		'HMAC-MD5':'MD5',
		'HMAC-SHA2-256':'SHA256',
		'HMAC-SHA2-384':'SHA384',
		'HMAC-SHA2-512':'SHA512',
		'HMAC-STREEBOG-256':'STREEBOG-256',
		'HMAC-STREEBOG-512':'STREEBOG-512',
		'GOST28147-TC26Z-IMIT':'GOST28147-TC26Z-IMIT'
	}

hash_not_map = {
		'AEAD':'AEAD',
		'SHA1':'SHA1',
		'MD5':'MD5',
		'SHA2-256':'SHA256',
		'SHA2-384':'SHA384',
		'SHA2-512':'SHA512',
		'SHA3-256':'SHA3-256',
		'SHA3-384':'SHA3-384',
		'SHA3-512':'SHA3-512',
		'STREEBOG-256':'STREEBOG-256',
		'STREEBOG-512':'STREEBOG-512',
		'GOSTR94':'GOSTR341194'
	}

group_not_map = {
		'X448':'GROUP-X448',
		'X25519':'GROUP-X25519',
		'SECP256R1':'GROUP-SECP256R1',
		'SECP384R1':'GROUP-SECP384R1',
		'SECP521R1':'GROUP-SECP521R1',
		'FFDHE-6144':'GROUP-FFDHE6144',
		'FFDHE-2048':'GROUP-FFDHE2048',
		'FFDHE-3072':'GROUP-FFDHE3072',
		'FFDHE-4096':'GROUP-FFDHE4096',
		'FFDHE-8192':'GROUP-FFDHE8192',
		'GOST-GC256B':'GROUP-GC256B',
		'GOST-GC512A':'GROUP-GC512A'
	}

sign_not_map = {
		'RSA-MD5':'RSA-MD5',
		'RSA-SHA1':'RSA-SHA1',
		'DSA-SHA1':'DSA-SHA1',
		'ECDSA-SHA1':'ECDSA-SHA1',
		'RSA-SHA2-224':'RSA-SHA224',
		'DSA-SHA2-224':'DSA-SHA224',
		'ECDSA-SHA2-224':'ECDSA-SHA224',
		'RSA-SHA2-256':'RSA-SHA256',
		'DSA-SHA2-256':'DSA-SHA256',
		'ECDSA-SHA2-256':'ECDSA-SHA256',
		'RSA-SHA2-384':'RSA-SHA384',
		'DSA-SHA2-384':'DSA-SHA384',
		'ECDSA-SHA2-384':'ECDSA-SHA384',
		'RSA-SHA2-512':'RSA-SHA512',
		'DSA-SHA2-512':'DSA-SHA512',
		'ECDSA-SHA2-512':'ECDSA-SHA512',
		# These are only available under 3.6.3+
		'RSA-PSS-SHA2-256':'RSA-PSS-SHA256',
		'RSA-PSS-SHA2-384':'RSA-PSS-SHA384',
		'RSA-PSS-SHA2-512':'RSA-PSS-SHA512',
		'RSA-PSS-RSAE-SHA2-256':'RSA-PSS-RSAE-SHA256',
		'RSA-PSS-RSAE-SHA2-384':'RSA-PSS-RSAE-SHA384',
		'RSA-PSS-RSAE-SHA2-512':'RSA-PSS-RSAE-SHA512',
		'EDDSA-ED448':'EDDSA-ED448',
		'EDDSA-ED25519':'EDDSA-ED25519',
		'GOSTR341012-512':'GOSTR341012-512',
		'GOSTR341012-256':'GOSTR341012-256',
		'GOSTR341001':'GOSTR341001'
	}

sign_force_map = {
		'DSA-SHA1':'DSA-SHA1',
		'DSA-SHA2-224':'DSA-SHA224',
		'DSA-SHA2-256':'DSA-SHA256',
		'DSA-SHA2-384':'DSA-SHA384',
		'DSA-SHA2-512':'DSA-SHA512',
	}

cipher_not_map = {
		'AES-256-CTR':'',
		'AES-128-CTR':'',
		'AES-256-GCM':'AES-256-GCM',
		'AES-128-GCM':'AES-128-GCM',
		'AES-256-CCM':'AES-256-CCM',
		'AES-128-CCM':'AES-128-CCM',
		'AES-256-CBC':'AES-256-CBC',
		'AES-128-CBC':'AES-128-CBC',
		'CAMELLIA-256-GCM':'CAMELLIA-256-GCM',
		'CAMELLIA-128-GCM':'CAMELLIA-128-GCM',
		'CAMELLIA-256-CBC':'CAMELLIA-256-CBC',
		'CAMELLIA-128-CBC':'CAMELLIA-128-CBC',
		'CHACHA20-POLY1305':'CHACHA20-POLY1305',
		'3DES-CBC':'3DES-CBC',
		'RC4-128':'ARCFOUR-128',
		'GOST28147-TC26Z-CFB':'GOST28147-TC26Z-CFB',
		'GOST28147-CPA-CFB':'GOST28147-CPA-CFB',
		'GOST28147-CPB-CFB':'GOST28147-CPB-CFB',
		'GOST28147-CPC-CFB':'GOST28147-CPC-CFB',
		'GOST28147-CPD-CFB':'GOST28147-CPD-CFB',
		'GOST28147-TC26Z-CNT':'GOST28147-TC26Z-CNT'
	}

cipher_force_map = {
		'3DES-CBC':'3DES-CBC',
		'RC4-128':'ARCFOUR-128'
	}

key_exchange_not_map = {
		#ECDHE is handled separately as it splits to ECDHE-ECDSA
		#and ECDHE-RSA.
		'RSA':'RSA',
		'DHE-RSA':'DHE-RSA',
		'DHE-DSS':'DHE-DSS',
		'PSK':'PSK',
		'DHE-PSK':'DHE-PSK',
		'ECDHE-PSK':'ECDHE-PSK',
		'RSA-PSK':'RSA-PSK',
		'VKO-GOST-2012':'VKO-GOST-12'
	}

key_exchange_force_map = {
		'DHE-DSS':'DHE-DSS'
	}

protocol_not_map = {
		'SSL3.0':'SSL3.0',
		'TLS1.0':'TLS1.0',
		'TLS1.1':'TLS1.1',
		'TLS1.2':'TLS1.2',
		'TLS1.3':'TLS1.3',
		'DTLS1.0':'DTLS1.0',
		'DTLS1.2':'DTLS1.2'
	}

@classmethod
	def generate_config(cls, policy):
		prio = 'NORMAL'
		s = ''
		p = policy.props
		ip = policy.inverted_props

s += "[overrides]\n"

if p['hash']:
			for i in ip['hash']:
				try:
					if cls.hash_not_map[i]:
						s += 'insecure-hash = '
						s += cls.hash_not_map[i]
						s += '\n'
				except KeyError:
					pass

if p['mac']:
			for i in ip['mac']:
				try:
					if cls.mac_not_map[i]:
						s += 'tls-disabled-mac = '
						s += cls.mac_not_map[i]
						s += '\n'
				except KeyError:
					pass

if p['group']:
			for i in ip['group']:
				try:
					if cls.group_not_map[i]:
						s += 'tls-disabled-group = '
						s += cls.group_not_map[i]
						s += '\n'
				except KeyError:
					pass

if p['sign']:
			for i in ip['sign']:
				try:
					if cls.sign_not_map[i]:
						s += 'insecure-sig = '
						s += cls.sign_not_map[i]
						s += '\n'
				except KeyError:
					pass
			for i in p['sign']:
				try:
					if cls.sign_force_map[i]:
						prio = cls.append(prio, '+SIGN-' + cls.sign_force_map[i])
				except KeyError:
					pass

if p['sha1_in_certs'] == 0:
			s += 'insecure-sig-for-cert = rsa-sha1\n'
			s += 'insecure-sig-for-cert = dsa-sha1\n'
			s += 'insecure-sig-for-cert = ecdsa-sha1\n'

if p['tls_cipher']:
			for i in ip['tls_cipher']:
				try:
					if cls.cipher_not_map[i]:
						s += 'tls-disabled-cipher = '
						s += cls.cipher_not_map[i]
						s += '\n'
				except KeyError:
					pass
			for i in p['tls_cipher']:
				try:
					if cls.cipher_force_map[i]:
						prio = cls.append(prio, '+' + cls.cipher_force_map[i])
				except KeyError:
					pass

if p['key_exchange']:
			for i in ip['key_exchange']:
				try:
					if i == 'ECDHE':
						s += 'tls-disabled-kx = ECDHE-RSA\n'
						s += 'tls-disabled-kx = ECDHE-ECDSA\n'
					elif cls.key_exchange_not_map[i]:
						s += 'tls-disabled-kx = '
						s += cls.key_exchange_not_map[i]
						s += '\n'
				except KeyError:
					pass
			for i in p['key_exchange']:
				try:
					if cls.key_exchange_force_map[i]:
						prio = cls.append(prio, '+' + cls.key_exchange_force_map[i])
				except KeyError:
					pass

if p['protocol']:
			for i in ip['protocol']:
				try:
					if cls.protocol_not_map[i]:
						s += 'disabled-version = '
						s += cls.protocol_not_map[i]
						s += '\n'
				except KeyError:
					pass

# We cannot separate RSA strength from DH params.
		if p['min_dh_size'] <= 768 or p['min_rsa_size'] <= 768:
			s += 'min-verification-profile = very_weak'
		elif p['min_dh_size'] <= 1024 or p['min_rsa_size'] <= 1024:
			s += 'min-verification-profile = low'
		elif p['min_dh_size'] <= 2048 or p['min_rsa_size'] <= 2048:
			s += 'min-verification-profile = medium'
		elif p['min_dh_size'] <= 3072 or p['min_rsa_size'] <= 3072:
			s += 'min-verification-profile = high'
		elif p['min_dh_size'] <= 8192 or p['min_rsa_size'] <= 8192:
			s += 'min-verification-profile = ultra'
		else:
			s += 'min-verification-profile = future'

s += '\n\n'
		s += "[priorities]\nSYSTEM=" + prio + '\n'

return s

@classmethod
	def test_config(cls, config):
		if not os.access('/usr/bin/gnutls-cli', os.X_OK):
			return True

fd, path = mkstemp()

ret = 255
		try:
			with os.fdopen(fd, 'w') as f:
				f.write(config)
			try:
				os.environ['GNUTLS_SYSTEM_PRIORITY_FILE'] = path
				os.environ['GNUTLS_DEBUG_LEVEL'] = '3'
				os.environ['GNUTLS_SYSTEM_PRIORITY_FAIL_ON_INVALID'] = '1'
				ret = call('/usr/bin/gnutls-cli -l >/dev/null',
					shell=True)
			except CalledProcessError:
				cls.eprint("/usr/bin/gnutls-cli: Execution failed")
		finally:
			del os.environ['GNUTLS_SYSTEM_PRIORITY_FILE']
			del os.environ['GNUTLS_DEBUG_LEVEL']
			del os.environ['GNUTLS_SYSTEM_PRIORITY_FAIL_ON_INVALID']
			os.unlink(path)

if ret:
			cls.eprint("There is an error in gnutls generated policy")
			cls.eprint("Policy:\n%s" % config)
			return False
		return True
0707010000002A000081A4000003E800000064000000016005CA7600000E28000000000000000000000000000000000000004800000000fedora-crypto-policies-20210118.b21c811/python/policygenerators/java.py# SPDX-License-Identifier: LGPL-2.1-or-later

from .configgenerator import ConfigGenerator

class JavaGenerator(ConfigGenerator):
	CONFIG_NAME = 'java'

hash_not_map = {
		'MD2' :'MD2',
		'MD5' :'MD5',
		'SHA1':'SHA1',
		'SHA2-224':'SHA224',
		'SHA2-256':'SHA256',
		'SHA2-384':'SHA384',
		'SHA2-512':'SHA512',
		'SHA3-256':'SHA3_256',
		'SHA3-384':'SHA3_384',
		'SHA3-512':'SHA3_512',
		'GOSTR94':''
	}

cipher_not_map = {
		'AES-256-CTR':'',
		'AES-128-CTR':'',
		'CHACHA20-POLY1305':'',
		'CAMELLIA-256-GCM':'',
		'CAMELLIA-128-GCM':'',
		'CAMELLIA-256-CBC':'',
		'CAMELLIA-128-CBC':'',
		'AES-256-CBC':'AES_256_CBC',
		'AES-128-CBC':'AES_128_CBC',
		'AES-256-GCM':'AES_256_GCM',
		'AES-128-GCM':'AES_128_GCM',
		'AES-256-CCM':'AES_256_CCM',
		'AES-128-CCM':'AES_128_CCM',
		'RC4-128':'RC4_128',
		'RC4-40':'RC4_40',
		'RC2-CBC':'RC2',
		'DES-CBC':'DES_CBC',
		'DES40-CBC':'DES40_CBC',
		'3DES-CBC' :'3DES_EDE_CBC',
		'SEED-CBC' :'',
		'IDEA-CBC' :'',
		'NULL':''
	}

cipher_legacy_map = {
		'RC4-128':'RC4_128',
		'3DES-CBC':'3DES_EDE_CBC',
	}

key_exchange_not_map = {
		'EXPORT':'RSA_EXPORT, DHE_DSS_EXPORT, DHE_RSA_EXPORT, DH_DSS_EXPORT, DH_RSA_EXPORT',
		'DH':'DH_RSA, DH_DSS',
		'ANON':'DH_anon, ECDH_anon',
		'RSA':'TLS_RSA_WITH_AES_256_CBC_SHA256, TLS_RSA_WITH_AES_256_CBC_SHA, TLS_RSA_WITH_AES_128_CBC_SHA256, TLS_RSA_WITH_AES_128_CBC_SHA, TLS_RSA_WITH_AES_256_GCM_SHA384, TLS_RSA_WITH_AES_128_GCM_SHA256',
		'DHE-RSA':'DHE_RSA',
		'DHE-DSS':'DHE_DSS',
		'ECDHE':'ECDHE',
		'ECDH':'ECDH',
		'PSK':'',
		'DHE-PSK':'',
		'ECDHE-PSK':'',
		'RSA-PSK':'RSAPSK'
	}

sign_not_map = {
		# we handle signature algorithms via disabled hashes
		'DSA-SHA1':'DSA',
		'RSA-SHA1':'',
		'ECDSA-SHA1':'',
		'RSA-MD5':''
	}

protocol_not_map = {
		'SSL2.0':'SSLv2',
		'SSL3.0':'SSLv3',
		'TLS1.0':'TLSv1',
		'TLS1.1':'TLSv1.1',
		'TLS1.2':'TLSv1.2',
		'DTLS1.0':'',
		'DTLS1.2':''
	}

mac_not_map = {
		'AEAD':'',
		'HMAC-MD5':'HmacMD5',
		'HMAC-SHA1':'HmacSHA1',
		'HMAC-SHA2-256':'HmacSHA256',
		'HMAC-SHA2-384':'HmacSHA384',
		'HMAC-SHA2-512':'HmacSHA512',
	}

@classmethod
	def generate_config(cls, policy):
		p = policy.props
		ip = policy.inverted_props
		sep = ', '

cfg = 'jdk.tls.ephemeralDHKeySize=' + str(p['min_dh_size']) + '\n'
		cfg += 'jdk.certpath.disabledAlgorithms='

s = ''
		s = cls.append(s, 'MD2', sep)
		for i in ip['hash']:
			try:
				s = cls.append(s, cls.hash_not_map[i], sep)
			except KeyError:
				pass

for i in ip['sign']:
			try:
				s = cls.append(s, cls.sign_not_map[i], sep)
			except KeyError:
				pass

s = cls.append(s, 'RSA keySize < ' + str(p['min_rsa_size']), sep)
		cfg += s

cfg += '\njdk.tls.disabledAlgorithms='

s = ''
		s = cls.append(s, 'DH keySize < ' + str(p['min_dh_size']), sep)

for i in ip['protocol']:
			try:
				s = cls.append(s, cls.protocol_not_map[i], sep)
			except KeyError:
				pass

for i in ip['key_exchange']:
			try:
				s = cls.append(s, cls.key_exchange_not_map[i], sep)
			except KeyError:
				pass

for i in ip['tls_cipher']:
			try:
				s = cls.append(s, cls.cipher_not_map[i], sep)
			except KeyError:
				pass

for i in ip['mac']:
			try:
				s = cls.append(s, cls.mac_not_map[i], sep)
			except KeyError:
				pass

cfg += s

cfg += '\njdk.tls.legacyAlgorithms='

s = ''
		for i in p['tls_cipher']:
			try:
				s = cls.append(s, cls.cipher_legacy_map[i], sep)
			except KeyError:
				pass

cfg += s

cfg += '\n'
		return cfg

@classmethod
	def test_config(cls, config):  #pylint: disable=unused-argument
		return True
0707010000002B000081A4000003E800000064000000016005CA76000005A8000000000000000000000000000000000000004800000000fedora-crypto-policies-20210118.b21c811/python/policygenerators/krb5.py# SPDX-License-Identifier: LGPL-2.1-or-later

from .configgenerator import ConfigGenerator

class KRB5Generator(ConfigGenerator):
	CONFIG_NAME = 'krb5'

cipher_map = {
		'CAMELLIA-256-CBC':'camellia256-cts-cmac',
		'CAMELLIA-128-CBC':'camellia128-cts-cmac',
		'CAMELLIA-128-CTS':'camellia128-cts-cmac'
	}

cipher_mac_map = {
		'AES-256-CBC-HMAC-SHA1':'aes256-cts-hmac-sha1-96',
		'AES-256-CBC-HMAC-SHA2-384':'aes256-cts-hmac-sha384-192',
		'AES-128-CBC-HMAC-SHA1':'aes128-cts-hmac-sha1-96',
		'AES-128-CBC-HMAC-SHA2-256':'aes128-cts-hmac-sha256-128',
		'RC4-128-HMAC-MD5':'arcfour-hmac-md5'
	}

@classmethod
	def generate_config(cls, policy):
		p = policy.props
		sep = ' '

cfg = '[libdefaults]\n'
		cfg += 'permitted_enctypes = '
		s = ''
		for i in p['cipher']:
			for j in p['mac']:
				try:
					s = cls.append(s,
						cls.cipher_mac_map[i + '-' + j], sep)
				except KeyError:
					pass
			try:
				s = cls.append(s, cls.cipher_map[i], sep)
			except KeyError:
				pass
		cfg += s + '\n'

# By default libkrb5 sets the min_bits to 2048, don't
		# go lower than that.
		if p['min_dh_size'] > 2048:
			# $string .= "pkinit_dh_min_bits=$min_dh_size\n";
			# krb5.conf only accepts 2048 or 4096
			cfg += 'pkinit_dh_min_bits=4096\n'

return cfg

@classmethod
	def test_config(cls, config):  #pylint: disable=unused-argument
		return True
0707010000002C000081A4000003E800000064000000016005CA760000169C000000000000000000000000000000000000004D00000000fedora-crypto-policies-20210118.b21c811/python/policygenerators/libreswan.py# SPDX-License-Identifier: LGPL-2.1-or-later

from subprocess import call, CalledProcessError
from tempfile import mkstemp

import os

from .configgenerator import ConfigGenerator

class LibreswanGenerator(ConfigGenerator):
	CONFIG_NAME = 'libreswan'

RELOAD_CMD = 'systemctl try-restart ipsec.service 2>/dev/null || :\n'

group_map = {
		'X448':'',
		'X25519':'dh31',
		'SECP256R1':'dh19',
		'SECP384R1':'dh20',
		'SECP521R1':'dh21',
		'FFDHE-6144':'',
		'FFDHE-1536':'dh5',
		'FFDHE-2048':'dh14',
		'FFDHE-3072':'dh15',
		'FFDHE-4096':'dh16',
		'FFDHE-8192':'dh18'
	}

cipher_map = {
		'AES-256-CBC':'aes256',
		'AES-192-CBC':'aes192',
		'AES-128-CBC':'aes128',
		'AES-256-GCM':'aes_gcm256',
		'AES-192-GCM':'aes_gcm192',
		'AES-128-GCM':'aes_gcm128',
		'CHACHA20-POLY1305':'chacha20_poly1305'
		# Unused for IKEv2
		# '3DES-CBC':'3des'
	}

cipher_prf_map = {
		'AES-256-CBC-HMAC-SHA2-512':'sha2_512',
		'AES-256-CBC-HMAC-SHA2-256':'sha2_256',
		'AES-192-CBC-HMAC-SHA2-512':'sha2_512',
		'AES-192-CBC-HMAC-SHA2-256':'sha2_256',
		'AES-128-CBC-HMAC-SHA2-256':'sha2_256',
		# Not needed for IKEv2
		# 'AES-256-CBC-HMAC-SHA1':'sha1',
		# 'AES-128-CBC-HMAC-SHA1':'sha1',
		'AES-256-GCM-HMAC-SHA2-512':'sha2_512',
		'AES-256-GCM-HMAC-SHA2-256':'sha2_256',
		'AES-192-GCM-HMAC-SHA2-512':'sha2_512',
		'AES-192-GCM-HMAC-SHA2-256':'sha2_256',
		'AES-128-GCM-HMAC-SHA2-512':'sha2_512',
		'AES-128-GCM-HMAC-SHA2-256':'sha2_256',
		'CHACHA20-POLY1305-HMAC-SHA2-512':'sha2_512',
		'CHACHA20-POLY1305-HMAC-SHA2-256':'sha2_256'
		# '3DES-CBC-HMAC-SHA1':'sha1'
	}

cipher_mac_map = {
		'AES-256-CBC-HMAC-SHA2-512':'sha2_512',
		'AES-192-CBC-HMAC-SHA2-512':'sha2_512',
		'AES-256-CBC-HMAC-SHA2-256':'sha2_256',
		'AES-192-CBC-HMAC-SHA2-256':'sha2_256',
		'AES-128-CBC-HMAC-SHA2-256':'sha2_256',
		'AES-256-CBC-HMAC-SHA1':'sha1',
		'AES-192-CBC-HMAC-SHA1':'sha1',
		'AES-128-CBC-HMAC-SHA1':'sha1',
		'AES-256-GCM-AEAD':'',
		'AES-192-GCM-AEAD':'',
		'AES-128-GCM-AEAD':'',
		'CHACHA20-POLY1305-AEAD':''
		# '3DES-CBC-HMAC-SHA1':'3des-sha1'
	}

sign_map = {
		'RSA-SHA1':'rsa-sha1',
		'ECDSA-SHA2-256':'ecdsa-sha2_256',
		'ECDSA-SHA2-384':'ecdsa-sha2_384',
		'ECDSA-SHA2-512':'ecdsa-sha2_512',
		'RSA-PSS-SHA2-256':'rsa-sha2_256',
		'RSA-PSS-SHA2-384':'rsa-sha2_384',
		'RSA-PSS-SHA2-512':'rsa-sha2_512',
		'RSA-PSS-RSAE-SHA2-256':'rsa-sha2_256',
		'RSA-PSS-RSAE-SHA2-384':'rsa-sha2_384',
		'RSA-PSS-RSAE-SHA2-512':'rsa-sha2_512'
	}

protocol_map = {
		'IKEv1':'ikev2=never',
		'IKEv2':'ikev2=insist'
	}

mac_ike_prio_map = {
		'AEAD':0,
		'HMAC-SHA2-512':1,
		'HMAC-SHA2-256':2,
		'HMAC-SHA1':3
	}

mac_esp_prio_map = {
		'AEAD':0,
		'HMAC-SHA2-512':1,
		'HMAC-SHA1':2,
		'HMAC-SHA2-256':3
	}

group_prio_map = {
		# sorted() guarantees stable order so we just put the two
		# most common groups first to avoid extra roundtrips
		'SECP256R1':0,
		'FFDHE-2048':1
	}

@classmethod
	def __get_ike_prio(cls, key):
		if key not in cls.mac_ike_prio_map:
			return 99
		return cls.mac_ike_prio_map[key]

@classmethod
	def __get_esp_prio(cls, key):
		if key not in cls.mac_esp_prio_map:
			return 99
		return cls.mac_esp_prio_map[key]

@classmethod
	def __get_group_prio(cls, key):
		if key not in cls.group_prio_map:
			return 99
		return cls.group_prio_map[key]

@classmethod
	def generate_config(cls, policy):
		cfg = 'conn %default\n'
		sep = ','
		p = policy.props

s = ''
		nproto = len(p['ike_protocol'])
		if nproto > 1:
			s = 'ikev2=permit'
		elif nproto > 0:
			s = cls.protocol_map[p['ike_protocol'][0]]
		if s:
			cfg += '\t' + s + '\n'

cfg += '\tpfs=yes\n'

sorted_macs = sorted(p['mac'],
			key=cls.__get_ike_prio)
		sorted_groups = sorted(p['group'],
			key=cls.__get_group_prio)

tmp = ''
		for cipher in p['cipher']:
			try:
				cm = cls.cipher_map[cipher]
			except KeyError:
				continue
			combo = cm + '-'
			s = ''
			for mac in sorted_macs:
				try:
					mm = cls.cipher_prf_map[cipher + '-' + mac]
				except KeyError:
					continue
				s = cls.append(s, mm, '+')
			if not s:
				continue
			combo += s
			s = ''
			for i in sorted_groups:
				try:
					group = cls.group_map[i]
				except KeyError:
					continue
				s = cls.append(s, group, '+')
			combo = cls.append(combo, s, '-')
			tmp = cls.append(tmp, combo, sep)

if tmp:
			cfg += '\tike=' + tmp + '\n'

sorted_macs = sorted(p['mac'],
			 key=cls.__get_esp_prio)

tmp = ''
		for cipher in p['cipher']:
			try:
				cm = cls.cipher_map[cipher]
			except KeyError:
				continue
			combo = cm + '-'
			s = ''
			for mac in sorted_macs:
				try:
					mm = cls.cipher_mac_map[cipher + '-' + mac]
				except KeyError:
					continue
				if not mm:
				# Special handling for AEAD
					combo = cm
					break
				s = cls.append(s, mm, '+')
			combo += s
			if combo[-1:] == '-':
				continue
			tmp = cls.append(tmp, combo, sep)

if tmp:
			cfg += '\tesp=' + tmp + '\n'

tmp = ''
		sigalgs = set()
		for sign in p['sign']:
			try:
				sm = cls.sign_map[sign]
			except KeyError:
				continue
			if sm not in sigalgs:
				sigalgs.add(sm)
				tmp = cls.append(tmp, sm, sep)
		if tmp:
			cfg += '\tauthby=' + tmp + '\n'

return cfg

@classmethod
	def test_config(cls, config):
		if not os.access('/usr/sbin/ipsec', os.X_OK):
			return True

fd, path = mkstemp()

ret = 255
		try:
			with os.fdopen(fd, 'w') as f:
				f.write(config)
			try:
				ret = call('/usr/sbin/ipsec readwriteconf --config ' + path +
					' >/dev/null',
					shell=True)
			except CalledProcessError:
				cls.eprint("/usr/sbin/ipsec: Execution failed")
		finally:
			os.unlink(path)

if ret:
			cls.eprint("There is an error in libreswan generated policy")
			cls.eprint("Policy:\n%s" % config)
			return False
		return True
0707010000002D000081A4000003E800000064000000016005CA7600000F26000000000000000000000000000000000000004A00000000fedora-crypto-policies-20210118.b21c811/python/policygenerators/libssh.py# SPDX-License-Identifier: LGPL-2.1-or-later

from .configgenerator import ConfigGenerator

class LibsshGenerator(ConfigGenerator):
	CONFIG_NAME = 'libssh'

cipher_map = {
		'AES-256-GCM':'aes256-gcm@openssh.com',
		'AES-256-CTR':'aes256-ctr',
		'AES-192-GCM':'',  # not supported
		'AES-192-CTR':'aes192-ctr',
		'AES-128-GCM':'aes128-gcm@openssh.com',
		'AES-128-CTR':'aes128-ctr',
		'CHACHA20-POLY1305':'chacha20-poly1305@openssh.com',
		'CAMELLIA-256-GCM':'',
		'AES-256-CCM':'',
		'AES-192-CCM':'',
		'AES-128-CCM':'',
		'CAMELLIA-128-GCM':'',
		'AES-256-CBC':'aes256-cbc',
		'AES-192-CBC':'aes192-cbc',
		'AES-128-CBC':'aes128-cbc',
		'CAMELLIA-256-CBC':'',
		'CAMELLIA-128-CBC':'',
		'RC4-128':'',
		'DES-CBC':'',
		'CAMELLIA-128-CTS':'',
		'3DES-CBC':'3des-cbc'
	}

mac_map_etm = {
		'HMAC-MD5':'',
		'UMAC-64':'',
		'UMAC-128':'',
		'HMAC-SHA1':'hmac-sha1-etm@openssh.com',
		'HMAC-SHA2-256':'hmac-sha2-256-etm@openssh.com',
		'HMAC-SHA2-512':'hmac-sha2-512-etm@openssh.com'
	}

mac_map = {
		'HMAC-MD5':'',
		'UMAC-64':'',
		'UMAC-128':'',
		'HMAC-SHA1':'hmac-sha1',
		'HMAC-SHA2-256':'hmac-sha2-256',
		'HMAC-SHA2-512':'hmac-sha2-512'
	}

kx_map = {
		'ECDHE-SECP521R1-SHA2-512':'ecdh-sha2-nistp521',
		'ECDHE-SECP256R1-SHA2-384':'ecdh-sha2-nistp384',
		'ECDHE-SECP256R1-SHA2-256':'ecdh-sha2-nistp256',
		'ECDHE-X25519-SHA2-256':'curve25519-sha256,curve25519-sha256@libssh.org',
		'DHE-FFDHE-1024-SHA1':'diffie-hellman-group1-sha1',
		'DHE-FFDHE-2048-SHA1':'diffie-hellman-group14-sha1',
		'DHE-FFDHE-2048-SHA2-256':'diffie-hellman-group14-sha256',
		'DHE-FFDHE-4096-SHA2-512':'diffie-hellman-group16-sha512',
		'DHE-FFDHE-8192-SHA2-512':'diffie-hellman-group18-sha512',
	}

gx_map = {
		'DHE-SHA1':'diffie-hellman-group-exchange-sha1',
		'DHE-SHA2-256':'diffie-hellman-group-exchange-sha256',
	}

sign_map = {
		'RSA-SHA1':'ssh-rsa,ssh-rsa-cert-v01@openssh.com',
		'DSA-SHA1':'ssh-dss,ssh-dss-cert-v01@openssh.com',
		'RSA-SHA2-256':'rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com',
		'RSA-SHA2-512':'rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com',
		'ECDSA-SHA2-256':'ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com',
		'ECDSA-SHA2-384':'ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com',
		'ECDSA-SHA2-512':'ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com',
		'EDDSA-ED25519':'ssh-ed25519,ssh-ed25519-cert-v01@openssh.com',
	}

@classmethod
	def generate_config(cls, policy):
		p = policy.props
		cfg = ''
		sep = ','

s = ''
		for i in p['ssh_cipher']:
			try:
				s = cls.append(s, cls.cipher_map[i], sep)
			except KeyError:
				pass

if s:
			cfg += 'Ciphers ' + s + '\n'

s = ''
		if p['ssh_etm'] == 1:
			for i in p['mac']:
				try:
					s = cls.append(s, cls.mac_map_etm[i], sep)
				except KeyError:
					pass
		for i in p['mac']:
			try:
				s = cls.append(s, cls.mac_map[i], sep)
			except KeyError:
				pass

if s:
			cfg += 'MACs ' + s + '\n'

s = ''
		for kx in p['key_exchange']:
		    for h in p['hash']:
		        if p['arbitrary_dh_groups'] == 1:
		            try:
		                val = cls.gx_map[kx + '-' + h]
		                s = cls.append(s, val, sep)
		            except KeyError:
		                pass
		        for g in p['ssh_group']:
		            try:
		                val = cls.kx_map[kx + '-' + g + '-' + h]
		                s = cls.append(s, val, sep)
		            except KeyError:
		                pass

if s:
			cfg += 'KexAlgorithms ' + s + '\n'

s = ''
		for i in p['sign']:
			try:
				s = cls.append(s, cls.sign_map[i], sep)
			except KeyError:
				pass

if s:
			cfg += 'HostKeyAlgorithms ' + s + '\n'
			cfg += 'PubkeyAcceptedKeyTypes ' + s + '\n'

return cfg

@classmethod
	def test_config(cls, config):  #pylint: disable=unused-argument
		return True
0707010000002E000081A4000003E800000064000000016005CA76000011D4000000000000000000000000000000000000004700000000fedora-crypto-policies-20210118.b21c811/python/policygenerators/nss.py# SPDX-License-Identifier: LGPL-2.1-or-later

from subprocess import call, CalledProcessError
from tempfile import mkstemp

import ctypes
import ctypes.util
import os

from .configgenerator import ConfigGenerator

class NSSGenerator(ConfigGenerator):
	CONFIG_NAME = 'nss'

mac_map = {
		'AEAD':'',
		'HMAC-SHA1':'HMAC-SHA1',
		'HMAC-MD5':'HMAC-MD5',
		'HMAC-SHA2-256':'HMAC-SHA256',
		'HMAC-SHA2-384':'HMAC-SHA384',
		'HMAC-SHA2-512':'HMAC-SHA512'
	}

hash_map = {
		'SHA1':'SHA1',
		'MD5':'MD5',
		'SHA2-224':'SHA224',
		'SHA2-256':'SHA256',
		'SHA2-384':'SHA384',
		'SHA2-512':'SHA512',
		'SHA3-256':'',
		'SHA3-384':'',
		'SHA3-512':'',
		'GOSTR94':''
	}

curve_map = {
		'X25519':'CURVE25519',
		'X448':'',
		'SECP256R1':'SECP256R1',
		'SECP384R1':'SECP384R1',
		'SECP521R1':'SECP521R1'
	}

cipher_map = {
		'AES-256-CTR':'',
		'AES-128-CTR':'',
		'RC2-CBC':'rc2',
		'RC4-128':'rc4',
		'AES-256-GCM':'aes256-gcm',
		'AES-128-GCM':'aes128-gcm',
		'AES-256-CBC':'aes256-cbc',
		'AES-128-CBC':'aes128-cbc',
		'CAMELLIA-256-CBC':'camellia256-cbc',
		'CAMELLIA-128-CBC':'camellia128-cbc',
		'CAMELLIA-256-GCM':'',
		'CAMELLIA-128-GCM':'',
		'AES-256-CCM':'',
		'AES-128-CCM':'',
		'CHACHA20-POLY1305':'chacha20-poly1305',
		'3DES-CBC':'des-ede3-cbc'
	}

key_exchange_map = {
		'PSK':'',
		'DHE-PSK':'',
		'ECDHE-PSK':'',
		'RSA-PSK':'',
		'RSA':'RSA',
		'DHE-RSA':'DHE-RSA',
		'DHE-DSS':'DHE-DSS',
		'ECDHE':'ECDHE-RSA:ECDHE-ECDSA',
		'ECDH':'ECDH-RSA:ECDH-ECDSA',
		'DH':'DH-RSA:DH-DSS'
	}

protocol_map = {
		'SSL3.0':'ssl3.0',
		'TLS1.0':'tls1.0',
		'TLS1.1':'tls1.1',
		'TLS1.2':'tls1.2',
		'TLS1.3':'tls1.3',
		'DTLS1.0':'dtls1.0',
		'DTLS1.2':'dtls1.2'
	}

# Depends on a dict being ordered,
	# impl. detail in CPython 3.6, guaranteed starting from Python 3.7.
	sign_prefix_ordmap = {
		'RSA-PSS-':'RSA-PSS',  # must come before RSA-
		'RSA-':'RSA-PKCS',
		'ECDSA-':'ECDSA',
		'DSA-':'DSA',
	}

@classmethod
	def generate_config(cls, policy):
		p = policy.props

cfg = 'library=\n'
		cfg += 'name=Policy\n'
		cfg += 'NSS=flags=policyOnly,moduleDB\n'
		cfg += 'config="disallow=ALL allow='

s = ''
		for i in p['mac']:
			try:
				s = cls.append(s, cls.mac_map[i])
			except KeyError:
				pass

for i in p['group']:
			try:
				s = cls.append(s, cls.curve_map[i])
			except KeyError:
				pass

for i in p['tls_cipher']:
			try:
				s = cls.append(s, cls.cipher_map[i])
			except KeyError:
				pass

for i in p['hash']:
			try:
				s = cls.append(s, cls.hash_map[i])
			except KeyError:
				pass

for i in p['key_exchange']:
			try:
				s = cls.append(s, cls.key_exchange_map[i])
			except KeyError:
				pass

enabled_sigalgs = set()
		for i in p['sign']:
			for prefix, sigalg in cls.sign_prefix_ordmap.items():
				if i.startswith(prefix):
					if sigalg not in enabled_sigalgs:
						enabled_sigalgs.add(sigalg)
						s = cls.append(s, sigalg)
					break  # limit to first match

try:
			minver = cls.protocol_map[p['min_tls_version']]
		except KeyError:
			minver = '0'
		s = cls.append(s, 'tls-version-min=' + minver)

try:
			minver = cls.protocol_map[p['min_dtls_version']]
		except KeyError:
			minver = '0'
		s = cls.append(s, 'dtls-version-min=' + minver)

s = cls.append(s, 'DH-MIN=' + str(p['min_dh_size']))
		s = cls.append(s, 'DSA-MIN=' + str(p['min_dsa_size']))
		s = cls.append(s, 'RSA-MIN=' + str(p['min_rsa_size']))

cfg += s + '"\n\n\n'
		return cfg

@classmethod
	def test_config(cls, config):
		try:
			nss_path = ctypes.util.find_library('nss3')
			nss_lib = ctypes.CDLL(nss_path)
			if not nss_lib.NSS_VersionCheck(b'3.60'):
				# Cannot validate with pre-3.59 NSS
				# that doesn't know ECDSA/RSA-PSS/RSA-PKCS
				# identifiers yet.
				# 3.60 because Fedora's 3.59 has that reverted
				cls.eprint('Skipping nss-policy-check due to '
				           'nss being older than 3.60')
				return True
		except AttributeError:
			cls.eprint('Cannot determine nss version with ctypes')

if not os.access('/usr/bin/nss-policy-check', os.X_OK):
			return True

fd, path = mkstemp()

ret = 255
		try:
			with os.fdopen(fd, 'w') as f:
				f.write(config)
			try:
				ret = call('/usr/bin/nss-policy-check ' + path +
					' >/dev/null',
					shell=True)
			except CalledProcessError:
				cls.eprint("/usr/bin/nss-policy-check: Execution failed")
		finally:
			os.unlink(path)

if ret:
			cls.eprint("There is an error in NSS generated policy")
			cls.eprint("Policy:\n%s" % config)
			return False
		return True
0707010000002F000081A4000003E800000064000000016005CA760000229A000000000000000000000000000000000000004B00000000fedora-crypto-policies-20210118.b21c811/python/policygenerators/openssh.py# SPDX-License-Identifier: LGPL-2.1-or-later

from subprocess import call, CalledProcessError
from tempfile import mkstemp

import os

from .configgenerator import ConfigGenerator

class OpenSSHGenerator(ConfigGenerator):
	_FORMAT_STRING = '{0} {1}\n'

mac_map_etm = {
		'HMAC-MD5':'hmac-md5-etm@openssh.com',
		'UMAC-64':'umac-64-etm@openssh.com',
		'UMAC-128':'umac-128-etm@openssh.com',
		'HMAC-SHA1':'hmac-sha1-etm@openssh.com',
		'HMAC-SHA2-256':'hmac-sha2-256-etm@openssh.com',
		'HMAC-SHA2-512':'hmac-sha2-512-etm@openssh.com'
	}

mac_map = {
		'HMAC-MD5':'hmac-md5',
		'UMAC-64':'umac-64@openssh.com',
		'UMAC-128':'umac-128@openssh.com',
		'HMAC-SHA1':'hmac-sha1',
		'HMAC-SHA2-256':'hmac-sha2-256',
		'HMAC-SHA2-512':'hmac-sha2-512'
	}

gx_map = {
		'DHE-SHA1':'diffie-hellman-group-exchange-sha1',
		'DHE-SHA2-256':'diffie-hellman-group-exchange-sha256',
	}

gss_kx_map = {
		'DHE-GSS-SHA1':'gss-gex-sha1-',
		'DHE-GSS-FFDHE-1024-SHA1':'gss-group1-sha1-',
		'DHE-GSS-FFDHE-2048-SHA1':'gss-group14-sha1-',
		'DHE-GSS-FFDHE-2048-SHA2-256':'gss-group14-sha256-',
		'ECDHE-GSS-SECP256R1-SHA2-256':'gss-nistp256-sha256-',
		'ECDHE-GSS-X25519-SHA2-256':'gss-curve25519-sha256-',
		'DHE-GSS-FFDHE-4096-SHA2-512':'gss-group16-sha512-',
	}

sign_map = {
		'RSA-SHA1':'ssh-rsa',
		'DSA-SHA1':'ssh-dss',
		'RSA-SHA2-256':'rsa-sha2-256',
		'RSA-SHA2-512':'rsa-sha2-512',
		'ECDSA-SHA2-256':'ecdsa-sha2-nistp256',
		'ECDSA-SHA2-256-FIDO':'sk-ecdsa-sha2-nistp256@openssh.com',
		'ECDSA-SHA2-384':'ecdsa-sha2-nistp384',
		'ECDSA-SHA2-512':'ecdsa-sha2-nistp521',
		'EDDSA-ED25519':'ssh-ed25519',
		'EDDSA-ED25519-FIDO':'sk-ssh-ed25519@openssh.com',
	}

sign_map_certs = {
		'RSA-SHA1':'ssh-rsa-cert-v01@openssh.com',
		'DSA-SHA1':'ssh-dss-cert-v01@openssh.com',
		'RSA-SHA2-256':'rsa-sha2-256-cert-v01@openssh.com',
		'RSA-SHA2-512':'rsa-sha2-512-cert-v01@openssh.com',
		'ECDSA-SHA2-256':'ecdsa-sha2-nistp256-cert-v01@openssh.com',
		'ECDSA-SHA2-256-FIDO':'sk-ecdsa-sha2-nistp256-cert-v01@openssh.com',
		'ECDSA-SHA2-384':'ecdsa-sha2-nistp384-cert-v01@openssh.com',
		'ECDSA-SHA2-512':'ecdsa-sha2-nistp521-cert-v01@openssh.com',
		'EDDSA-ED25519':'ssh-ed25519-cert-v01@openssh.com',
		'EDDSA-ED25519-FIDO':'sk-ssh-ed25519-cert-v01@openssh.com',
	}

@classmethod
	def generate_options(cls, policy, local_kx_map, local_gss_kx_map, do_host_key):
		p = policy.props
		cfg = ''
		sep = ','

s = ''
		for i in p['ssh_cipher']:
			try:
				s = cls.append(s, cls.cipher_map[i], sep)
			except KeyError:
				pass

if s:
			cfg += cls._FORMAT_STRING.format('Ciphers', s)

if s:
			cfg += cls._FORMAT_STRING.format('MACs', s)

s = ''
		gss = ''
		for kx in p['key_exchange']:
		    for h in p['hash']:
		        if p['arbitrary_dh_groups'] == 1:
		            try:
		                val = cls.gx_map[kx + '-' + h]
		                s = cls.append(s, val, sep)
		            except KeyError:
		                pass
		            try:
		                val = local_gss_kx_map[kx + '-' + h]
		                gss = cls.append(gss, val, sep)
		            except KeyError:
		                pass
		        for g in p['ssh_group']:
		            try:
		                val = local_kx_map[kx + '-' + g + '-' + h]
		                s = cls.append(s, val, sep)
		            except KeyError:
		                pass
		            try:
		                val = local_gss_kx_map[kx + '-' + g + '-' + h]
		                gss = cls.append(gss, val, sep)
		            except KeyError:
		                pass

if gss:
			cfg += cls._FORMAT_STRING.format('GSSAPIKexAlgorithms', gss)
		else:
			cfg += cls._FORMAT_STRING.format('GSSAPIKeyExchange', 'no')

if s:
			cfg += cls._FORMAT_STRING.format('KexAlgorithms', s)

s = ''
		for i in p['sign']:
			try:
				s = cls.append(s, cls.sign_map[i], sep)
			except KeyError:
				pass
			if p['ssh_certs'] == 1:
				try:
					s = cls.append(s, cls.sign_map_certs[i], sep)
				except KeyError:
					pass

if s:
			# As OpenSSH currently ignores existing known host
			# entries with this setting we cannot use it on client.
			# Otherwise we could break existing users.
			if do_host_key:
				cfg += cls._FORMAT_STRING.format('HostKeyAlgorithms', s)
			cfg += cls._FORMAT_STRING.format('PubkeyAcceptedKeyTypes', s)

s = ''
		for i in p['sign']:
			try:
				s = cls.append(s, cls.sign_map[i], sep)
			except KeyError:
				pass

if s:
			cfg += cls._FORMAT_STRING.format('CASignatureAlgorithms', s)

return cfg

class OpenSSHClientGenerator(OpenSSHGenerator):
	CONFIG_NAME = 'openssh'

@classmethod
	def generate_config(cls, policy):
		local_kx_map = dict(cls.kx_map)
		local_gss_kx_map = dict(cls.gss_kx_map)

return cls.generate_options(policy, local_kx_map, local_gss_kx_map, False)

@classmethod
	def test_config(cls, config):
		if not os.access('/usr/bin/ssh', os.X_OK):
			return True

fd, path = mkstemp()

ret = 255
		try:
			with os.fdopen(fd, 'w') as f:
				f.write(config)
			try:
				ret = call('/usr/bin/ssh -G -F ' + path +
					' bogus654_server >/dev/null',
					shell=True)
			except CalledProcessError:
				cls.eprint("/usr/bin/ssh: Execution failed")
		finally:
			os.unlink(path)

if ret and config.find('sk-') != -1:
			cls.eprint("Ignoring the OpenSSH check result with sk- algos in config")
			ret = False
		if ret:
			cls.eprint("There is an error in OpenSSH server generated policy")
			cls.eprint("Policy:\n%s" % config)
			return False
		return True

class OpenSSHServerGenerator(OpenSSHGenerator):
	CONFIG_NAME = 'opensshserver'

# We need restart here, since systemd needs to pick up new command line options
	RELOAD_CMD = 'systemctl try-restart sshd.service 2>/dev/null || :\n'

@classmethod
	def generate_config(cls, policy):
		# Difference from client, keep group1 disabled on server
		local_kx_map = dict(cls.kx_map)
		local_gss_kx_map = dict(cls.gss_kx_map)
		del local_kx_map['DHE-FFDHE-1024-SHA1']
		del local_gss_kx_map['DHE-GSS-FFDHE-1024-SHA1']

return cls.generate_options(policy, local_kx_map, local_gss_kx_map, True)

@classmethod
	def _test_setup(cls):
		_fd, path = mkstemp()
		os.unlink(path)
		ret = 255
		try:
			ret = call('/usr/bin/ssh-keygen -t rsa -b 2048 -f ' + path +
				' -N "" >/dev/null',
				shell=True)
		except CalledProcessError:
			cls.eprint("/usr/bin/ssh-keygen: Execution failed")

if ret:
			cls.eprint("SSH Keygen failed when testing OpenSSH server policy")
			return ''
		return path

@classmethod
	def _test_cleanup(cls, path):
		if path:
			os.unlink(path)

@classmethod
	def test_config(cls, config):
		if not os.access('/usr/sbin/sshd', os.X_OK):
			return True

host_key_filename = cls._test_setup()
		if not host_key_filename:
			return False

fd, path = mkstemp()

ret = 255
		try:
			with os.fdopen(fd, 'w') as f:
				f.write(config)
			try:
				ret = call('/usr/sbin/sshd -T -h '
					+ host_key_filename +
					' -f ' + path + ' >/dev/null',
					shell=True)
			except CalledProcessError:
				cls.eprint("/usr/sbin/sshd: Execution failed")
		finally:
			os.unlink(path)
			cls._test_cleanup(host_key_filename)

if ret and config.find('sk-') != -1:
			cls.eprint("Ignoring the OpenSSH check result with sk- algos in config")
			ret = False
		if ret and config.find('sk-') == -1:
			cls.eprint("There is an error in OpenSSH server generated policy")
			cls.eprint("Policy:\n%s" % config)
			return False
		return True
07070100000030000081A4000003E800000064000000016005CA7600001713000000000000000000000000000000000000004B00000000fedora-crypto-policies-20210118.b21c811/python/policygenerators/openssl.py# SPDX-License-Identifier: LGPL-2.1-or-later

from subprocess import check_output, CalledProcessError

from .configgenerator import ConfigGenerator

class OpenSSLGenerator(ConfigGenerator):
	CONFIG_NAME = 'openssl'

cipher_not_map = {
		'AES-256-CTR':'',
		'AES-128-CTR':'',
		'AES-256-GCM':'-AES256',
		'AES-128-GCM':'-AES128',
		'AES-256-CBC':'-SHA256',
		'AES-128-CBC':'',
		'CHACHA20-POLY1305':'-CHACHA20-POLY1305',
		'SEED-CBC':'-SEED',
		'IDEA-CBC':'!IDEA',
		'DES-CBC':'!DES',
		'RC4-40':'',
		'DES40-CBC':'',
		'3DES-CBC':'-3DES',
		'RC4-128':'!RC4',
		'RC2-CBC':'!RC2',
		'NULL':'!eNULL:!aNULL'
	}

key_exchange_map = {
		'RSA':'kRSA',
		'ECDHE':'kEECDH',
		'PSK':'kPSK',
		'DHE-PSK':'kDHEPSK',
		'DHE-RSA':'kEDH',
		'DHE-DSS':'',
		'ECDHE-PSK':'kECDHEPSK',
		'RSA-PSK':'kRSAPSK',
		'VKO-GOST-2012':'kGOST'
	}

key_exchange_not_map = {
		'ANON':'',
		'DH':'',
		'ECDH':'',
		'RSA':'-kRSA',
		'ECDHE':'-kEECDH',
		'DHE-RSA':'-aRSA',
		'DHE-DSS':'-aDSS',
		'PSK':'-kPSK',
		'DHE-PSK':'-kDHEPSK',
		'ECDHE-PSK':'-kECDHEPSK',
		'RSA-PSK':'-kRSAPSK'
	}

mac_not_map = {
		'HMAC-MD5':'!MD5',
		'HMAC-SHA1':'-SHA1'
	}

ciphersuite_map = {
		'AES-256-GCM':'TLS_AES_256_GCM_SHA384',
		'AES-128-GCM':'TLS_AES_128_GCM_SHA256',
		'CHACHA20-POLY1305':'TLS_CHACHA20_POLY1305_SHA256',
		'AES-128-CCM':'TLS_AES_128_CCM_SHA256',
		'AES-128-CCM8':'TLS_AES_128_CCM_8_SHA256',
		'GOST28147-TC26Z-CNT':'GOST2012-GOST8912-GOST8912',
		'GOST28147-CPA-CNT':'GOST2001-GOST89-GOST89'
	}

@classmethod
	def generate_ciphers(cls, policy):
		s = ''
		p = policy.props
		ip = policy.inverted_props
		# We cannot separate RSA strength from DH params.
		if p['min_dh_size'] < 1023 or p['min_rsa_size'] < 1023:
			s = cls.append(s, '@SECLEVEL=0')
		elif p['min_dh_size'] < 2048 or p['min_rsa_size'] < 2048:
			s = cls.append(s, '@SECLEVEL=1')
		elif p['min_dh_size'] < 3072 or p['min_rsa_size'] < 3072:
			s = cls.append(s, '@SECLEVEL=2')
		else:
			s = cls.append(s, '@SECLEVEL=3')

for i in p['key_exchange']:
			try:
				s = cls.append(s, cls.key_exchange_map[i])
			except KeyError:
				pass

for i in ip['key_exchange']:
			try:
				s = cls.append(s, cls.key_exchange_not_map[i])
			except KeyError:
				pass

for i in ip['tls_cipher']:
			try:
				s = cls.append(s, cls.cipher_not_map[i])
			except KeyError:
				pass
		if 'AES-128-CCM' in ip['tls_cipher'] and 'AES-256-CCM' in ip['tls_cipher']:
			s = cls.append(s, '-AESCCM')

for i in ip['mac']:
			try:
				s = cls.append(s, cls.mac_not_map[i])
			except KeyError:
				pass

# These ciphers are not necessary for any
		# policy level, and only increase the attack surface.
		# FIXME! must be fixed for custom policies
		s = cls.append(s, '-SHA384')
		s = cls.append(s, '-CAMELLIA')
		s = cls.append(s, '-ARIA')
		s = cls.append(s, '-AESCCM8')

return s

@classmethod
	def generate_ciphersuites(cls, policy):
		s = ''
		p = policy.props
		for i in p['tls_cipher']:
			try:
				s = cls.append(s, cls.ciphersuite_map[i])
			except KeyError:
				pass

return s

@classmethod
	def generate_config(cls, policy):
		return cls.generate_ciphers(policy)

@classmethod
	def test_config(cls, config):
		output = b''
		try:
			output = check_output(["openssl", "ciphers", config])
		except CalledProcessError:
			cls.eprint("There is an error in openssl generated policy")
			cls.eprint("policy: %s" % config)
			return False
		except OSError:
			# Ignore missing openssl
			return True
		if b'NULL' in output or b'ADH' in output:
			cls.eprint("There is NULL or ADH in openssl generated policy")
			cls.eprint("Policy:\n%s" % config)
			return False
		return True

class OpenSSLConfigGenerator(OpenSSLGenerator):
	CONFIG_NAME = 'opensslcnf'

TLS_PROTOCOLS = {
		'SSLv3':(3, 0),
		'TLSv1':(3, 1),
		'TLSv1.1':(3, 2),
		'TLSv1.2':(3, 3),
		'TLSv1.3':(3, 4),
	}

protocol_map = {
			 'SSL3.0':'SSLv3',
			 'TLS1.0':'TLSv1',
			 'TLS1.1':'TLSv1.1',
			 'TLS1.2':'TLSv1.2',
			 'TLS1.3':'TLSv1.3',
			 'DTLS1.0':'DTLSv1',
			 'DTLS1.2':'DTLSv1.2'
	}

sign_map = {
		'RSA-SHA1':'RSA+SHA1',
		'DSA-SHA1':'DSA+SHA1',
		'ECDSA-SHA1':'ECDSA+SHA1',
		'RSA-SHA2-224':'RSA+SHA224',
		'DSA-SHA2-224':'DSA+SHA224',
		'ECDSA-SHA2-224':'ECDSA+SHA224',
		'RSA-SHA2-256':'RSA+SHA256',
		'DSA-SHA2-256':'DSA+SHA256',
		'ECDSA-SHA2-256':'ECDSA+SHA256',
		'RSA-SHA2-384':'RSA+SHA384',
		'DSA-SHA2-384':'DSA+SHA384',
		'ECDSA-SHA2-384':'ECDSA+SHA384',
		'RSA-SHA2-512':'RSA+SHA512',
		'DSA-SHA2-512':'DSA+SHA512',
		'ECDSA-SHA2-512':'ECDSA+SHA512',
		'RSA-PSS-SHA2-256':'rsa_pss_pss_sha256',
		'RSA-PSS-SHA2-384':'rsa_pss_pss_sha384',
		'RSA-PSS-SHA2-512':'rsa_pss_pss_sha512',
		'RSA-PSS-RSAE-SHA2-256':'rsa_pss_rsae_sha256',
		'RSA-PSS-RSAE-SHA2-384':'rsa_pss_rsae_sha384',
		'RSA-PSS-RSAE-SHA2-512':'rsa_pss_rsae_sha512',
		'EDDSA-ED25519':'ed25519',
		'EDDSA-ED448':'ed448'
	}

@classmethod
	def generate_config(cls, policy):
		p = policy.props
		s = 'CipherString = '
		# This includes the seclevel
		s += cls.generate_ciphers(policy)
		s += '\n'

s += 'Ciphersuites = '
		s += cls.generate_ciphersuites(policy)
		s += '\n'

# Unfortunately there is no practical way to set minimum DTLS version
		s += 'MinProtocol = '
		try:
			s += cls.protocol_map[p['min_tls_version']]
		except KeyError:
			pass
		s += '\n'

protocol = [cls.protocol_map[i] for i in p['protocol']]
		tls_protocol = [(pp, cls.TLS_PROTOCOLS[pp])
				 for pp in protocol
				 if pp in cls.TLS_PROTOCOLS]
		if tls_protocol:
			tls_protocol.sort(key=lambda x: x[1])
			s += 'MaxProtocol = '
			try:
				s += tls_protocol[-1][0]
			except KeyError:
				pass
			s += '\n'

sig_algs = [cls.sign_map[i]
				for i in p['sign'] if i in cls.sign_map]
		s += 'SignatureAlgorithms = ' + ':'.join(sig_algs)

return s

@classmethod
	def test_config(cls, config):  #pylint: disable=unused-argument
		return True
07070100000031000081ED000003E800000064000000016005CA76000028AD000000000000000000000000000000000000004900000000fedora-crypto-policies-20210118.b21c811/python/update-crypto-policies.py#!/usr/bin/python3

# SPDX-License-Identifier: LGPL-2.1-or-later

import sys
import argparse
import os
import subprocess
from tempfile import mkstemp, mkdtemp
import glob
import shutil

import cryptopolicies
from cryptopolicies.cryptopolicies import eprint

import policygenerators

DEFAULT_PROFILE_DIR = '/usr/share/crypto-policies'
DEFAULT_BASE_DIR = '/etc/crypto-policies'
RELOAD_CMD_NAME = 'reload-cmds.sh'
FIPS_MODE_FLAG = '/proc/sys/crypto/fips_enabled'

profile_dir = None
base_dir = None
local_dir = None
backend_config_dir = None
state_dir = None
reload_cmd_path = None

def dir_paths(alt_base=None):
	# pylint: disable=W0603
	global profile_dir
	global base_dir
	global local_dir
	global backend_config_dir
	global state_dir
	global reload_cmd_path

try:
		profile_dir = os.environ['profile_dir']
		cryptopolicies.CryptoPolicy.SHARE_DIR = profile_dir
	except KeyError:
		profile_dir = DEFAULT_PROFILE_DIR

if alt_base is not None:
		base_dir = alt_base
	else:
		try:
			base_dir = os.environ['base_dir']
			cryptopolicies.CryptoPolicy.CONFIG_DIR = base_dir
		except KeyError:
			base_dir = DEFAULT_BASE_DIR

local_dir = os.path.join(base_dir, 'local.d')
	backend_config_dir = os.path.join(base_dir, 'back-ends')
	state_dir = os.path.join(base_dir, 'state')

reload_cmd_path = os.path.join(profile_dir, RELOAD_CMD_NAME)

def get_walk(path):
	# NOTE: filecmp.dircmp compares mtimes, which are irrelevant.
	#       Comparing file lists and contents instead.
	old_cwd = os.getcwd()
	os.chdir(path)
	walk = sorted(os.walk("."))
	os.chdir(old_cwd)
	return walk

def parse_args():
	"Parse the command line"
	parser = argparse.ArgumentParser(allow_abbrev=False)
	group = parser.add_mutually_exclusive_group()
	group.add_argument('--set', nargs='?', default='', metavar='POLICY',
		help='set the policy POLICY')
	group.add_argument('--show', action='store_true',
		help='show the current policy from the configuration')
	group.add_argument('--is-applied', action='store_true',
		help='check whether the current policy is applied')
	group.add_argument('--check', action='store_true',
		help='check whether the generated policy files match the current policy')
	parser.add_argument('--no-check', action='store_true',
		help=argparse.SUPPRESS)
	parser.add_argument('--no-reload', action='store_true',
		help='do not run the reload scripts when setting a policy')
	return parser.parse_args()

def is_applied():
	try:
		time1 = os.stat(os.path.join(state_dir, 'current')).st_mtime
		time2 = os.stat(os.path.join(base_dir, 'config')).st_mtime
	except OSError:
		sys.exit(77)

if time1 >= time2:
		print("The configured policy is applied")
		sys.exit(0)
	print("The configured policy is NOT applied")
	sys.exit(1)

def check():
	orig_base_dir = base_dir
	orig_local_dir = local_dir
	orig_backend_config_dir = backend_config_dir
	orig_state_dir = state_dir

alt_base = mkdtemp()
	dir_paths(alt_base=alt_base)

# These are the *inputs* for generating the resulting configuration.
	shutil.copytree(src=orig_local_dir, dst=local_dir)
	shutil.copy(src=os.path.join(orig_base_dir, 'config'), dst=os.path.join(base_dir, 'config'))

# generate configuration for the current policy in alt_base path instead of default
	setup_directories()
	pconfig = parse_pconfig()
	apply_policy(pconfig, print_enabled=False)

walk_orig_backend = get_walk(orig_backend_config_dir)
	walk_backend = get_walk(backend_config_dir)
	walk_orig_state = get_walk(orig_state_dir)
	walk_state = get_walk(state_dir)

err = False
	if walk_orig_backend != walk_backend:
		err = True
	if walk_orig_state != walk_state:
		err = True
	for orig_prefix, tmp_prefix, walk in ((orig_backend_config_dir, backend_config_dir, walk_backend), (orig_state_dir, state_dir, walk_state)):
		for d, _, fl in walk:
			for f in fl:
				if err:
					break
				f_orig = os.path.join(orig_prefix, d, f)
				f_tmp = os.path.join(tmp_prefix, d, f)
				with open(f_orig, 'rb') as fp1, open(f_tmp, 'rb') as fp2:
					# inspired by Python 3.8's filecmp._do_cmp()
					while not err:
						b1 = fp1.read(8192)
						b2 = fp2.read(8192)
						if b1 != b2:
							err = True
						if not b1:
							break

shutil.rmtree(alt_base)
	if err:
		eprint("The configured policy does NOT match the generated policy")
		sys.exit(1)
	else:
		print("The configured policy matches the generated policy")
		sys.exit(0)

def setup_directories():
	try:
		os.makedirs(backend_config_dir)
		os.makedirs(state_dir)
	except OSError:
		pass

def fips_mode():
	try:
		with open(FIPS_MODE_FLAG) as f:
			return int(f.read()) > 0
	except OSError:
		return False

def safe_write(directory, filename, contents):
	(fd, path) = mkstemp(prefix=filename, dir=directory)
	os.write(fd, bytes(contents, 'utf-8'))
	os.fsync(fd)
	os.fchmod(fd, 0o644)
	try:
		os.rename(path, os.path.join(directory, filename))
	except OSError as e:
		os.unlink(path)
		os.close(fd)
		raise e
	finally:
		os.close(fd)

def safe_symlink(directory, filename, target):
	(fd, path) = mkstemp(prefix=filename, dir=directory)
	os.close(fd)
	os.unlink(path)
	os.symlink(target, path)
	try:
		os.rename(path, os.path.join(directory, filename))
	except OSError as e:
		os.unlink(path)
		raise e

def save_config(pconfig, cfgname, cfgdata, cfgdir, localdir, profiledir):
	local_cfg_path = os.path.join(localdir, cfgname + '-*.config')
	local_cfgs = sorted(glob.glob(local_cfg_path))
	local_cfg_present = False

for lcfg in local_cfgs:
		if os.path.exists(lcfg):
			local_cfg_present = True

profilepath = os.path.join(profiledir, str(pconfig), cfgname + '.txt')

if not local_cfg_present and os.access(profilepath, os.R_OK):
		safe_symlink(cfgdir, cfgname + '.config', profilepath)
		return

safe_write(cfgdir, cfgname + '.config', cfgdata)

if local_cfg_present:
		cfgfile = os.path.join(cfgdir, cfgname + '.config')
		for lcfg in local_cfgs:
			try:
				with open(lcfg, 'r') as lf:
					local_data = lf.read()
			except OSError:
				eprint("Cannot read local policy file " + cfgname)
				continue

try:
				with open(cfgfile, 'a') as cf:
					cf.write(local_data)
			except OSError:
				eprint("Error applying local configuration to " + cfgname)

class ProfileConfig:
	def __init__(self):
		self.policy = ''
		self.subpolicies = []

def parse_string(self, s, subpolicy=False):
		l = s.upper().split(':')
		if l[0] and not subpolicy:
			self.policy = l[0]
			l = l[1:]
		l = [i for i in l if l]
		if subpolicy:
			self.subpolicies.append(l)
		else:
			self.subpolicies = l

def parse_file(self, filename):
		subpolicy = False
		with open(filename) as f:
			for line in f:
				line = line.split('#', 1)[0]
				line = line.strip()
				if line:
					self.parse_string(line, subpolicy)
					subpolicy = True

def remove_subpolicies(self, s):
		l = s.upper().split(':')
		self.subpolicies = [i for i in self.subpolicies if not i in l]

def __str__(self):
		s = self.policy
		subs = ':'.join(self.subpolicies)
		if subs:
			s = s + ':' + subs
		return s

def show(self):
		print(str(self))

def parse_pconfig():
	pconfig = ProfileConfig()

configfile = os.path.join(base_dir, 'config')
	if os.access(configfile, os.R_OK):
		pconfig.parse_file(configfile)
	elif fips_mode():
		pconfig.parse_string('FIPS')
	else:
		pconfig.parse_file(os.path.join(profile_dir, 'default-config'))

return pconfig

def apply_policy(pconfig, profile=None, print_enabled=True):
	err = 0
	set_config = False

if profile:
		oldpolicy = pconfig.policy
		pconfig.parse_string(profile)
		set_config = True

# FIPS profile is a special case
		if pconfig.policy != oldpolicy and print_enabled:
			if pconfig.policy == 'FIPS':
				eprint("Warning: Using 'update-crypto-policies --set FIPS' is not sufficient for")
				eprint("         FIPS compliance.")
				eprint("         Use 'fips-mode-setup --enable' command instead.")
			elif fips_mode():
				eprint("Warning: Using 'update-crypto-policies --set' in FIPS mode will make the system")
				eprint("         non-compliant with FIPS.")
				eprint("         It can also break the ssh access to the system.")
				eprint("         Use 'fips-mode-setup --disable' to disable the system FIPS mode.")

if base_dir == DEFAULT_BASE_DIR:
		if not os.geteuid() == 0:
			eprint("You must be root to run update-crypto-policies.")
			sys.exit(1)

cp = cryptopolicies.CryptoPolicy()

try:
		cp.load_policy(pconfig.policy)
		cp.load_subpolicies(pconfig.subpolicies)
	except ValueError as e:
		eprint('Error: ' + str(e))
		sys.exit(1)

if cp.errors:
		eprint('Errors found in policy')
		sys.exit(1)

cp.finalize()

if print_enabled:
		print("Setting system policy to " + str(pconfig))

generators = [g for g in dir(policygenerators) if 'Generator' in g]

for g in generators:
		cls = policygenerators.__dict__[g]
		gen = cls()
		try:
			config = gen.generate_config(cp)
		except LookupError:
			eprint('Error generating config for ' + gen.CONFIG_NAME)
			eprint('Keeping original configuration')
			err = 1

try:
			save_config(pconfig, gen.CONFIG_NAME, config,
				    backend_config_dir, local_dir, profile_dir)
		except OSError:
			eprint('Error saving config for ' + gen.CONFIG_NAME)
			eprint('Keeping original configuration')
			err = 1

if set_config:
		try:
			safe_write(base_dir, 'config', str(pconfig) + '\n')
		except OSError:
			eprint('Error setting the current policy configuration')
			err = 3

try:
		safe_write(state_dir, 'current', str(pconfig) + '\n')
	except OSError:
		eprint('Error updating current policy marker')
		err = 2

try:
		safe_write(state_dir, 'CURRENT.pol', str(cp))
	except OSError:
		eprint('Error updating current policy dump')
		err = 2

if print_enabled:
		print("Note: System-wide crypto policies are applied on application start-up.")
		print("It is recommended to restart the system for the change of policies")
		print("to fully take place.")

return err

def main():
	"The actual command implementation"

dir_paths()

cmdline = parse_args()

if cmdline.is_applied:
		is_applied()
		sys.exit(0)

if cmdline.check:
		check()
		sys.exit(0)

setup_directories()

pconfig = parse_pconfig()

if cmdline.show:
		pconfig.show()
		sys.exit(0)

profile = cmdline.set

err = apply_policy(pconfig, profile)

if not cmdline.no_reload:
		subprocess.call(['/bin/bash', reload_cmd_path])

sys.exit(err)

# Entry point
if __name__ == "__main__":
	main()
07070100000032000041ED000003E800000064000000046005CA7600000000000000000000000000000000000000000000002E00000000fedora-crypto-policies-20210118.b21c811/tests07070100000033000081ED000003E800000064000000016005CA7600000389000000000000000000000000000000000000003800000000fedora-crypto-policies-20210118.b21c811/tests/gnutls.pl#!/usr/bin/perl

my $TMPFILE="out-gnutls.tmp";

print "Checking the GnuTLS configuration\n";

my $dir = 'tests/outputs';

opendir(DIR, $dir) or die $!;

my @gnutlspolicies
    = grep {
        /gnutls/          # has gnutls in name
        && -f "$dir/$_"   # and is a file
    } readdir(DIR);

foreach my $policyfile (@gnutlspolicies) {
	my $policy = $policyfile;
	$policy =~ s/-[^-]+$//;

print "Checking policy $policy\n";
	next if $policy eq 'GOST-ONLY';

system("GNUTLS_DEBUG_LEVEL=3 GNUTLS_SYSTEM_PRIORITY_FILE=$dir/$policyfile GNUTLS_SYSTEM_PRIORITY_FAIL_ON_INVALID=1 gnutls-cli -l >$TMPFILE 2>&1");
	if ($? == 0 && $policy eq 'EMPTY') {
		print "Error in gnutls empty policy ($policy)\n";
		system("cat $TMPFILE 1>&2");
		exit 1;
	} elsif ($? != 0 && $policy ne 'EMPTY') {
		print "Error in gnutls policy for $policy\n";
		system("cat $TMPFILE 1>&2");
		exit 1;
	}
	unlink($TMPFILE);
}

exit 0;
07070100000034000041ED000003E800000064000000026005CA7600000000000000000000000000000000000000000000003300000000fedora-crypto-policies-20210118.b21c811/tests/java07070100000035000081ED000003E800000064000000016005CA7600000606000000000000000000000000000000000000003600000000fedora-crypto-policies-20210118.b21c811/tests/java.pl#!/usr/bin/perl

use File::pushd;

my $TMPFILE="out-java.$$.tmp";

print "Checking the Java configuration\n";

print STDERR "Java ciphersuites per policy\n";

system("javac tests/java/CipherList.java 1>&2");
if ($? != 0) {
	exit 77;
}

my $dir = 'tests/outputs';

opendir(DIR, $dir) or die $!;

my @javapolicies
    = grep {
        /java/          # has java in name
        && -f "$dir/$_"   # and is a file
    } readdir(DIR);

foreach my $policyfile (@javapolicies) {
	my $policy = $policyfile;
	$policy =~ s/-[^-]+$//;

print "Checking policy $policy\n";

{
		my $pushdir = pushd('tests/java');

#catch errors in this script now, since the -D option will ignore
		#missing files.
		if (!-e "../../$dir/$policyfile") {
			print "Policy file ../../$dir/$policyfile missing\n";
			exit 1;
		}
		system("java -Djava.security.disableSystemPropertiesFile -Djava.security.properties=\"../../$dir/$policyfile\" CipherList >../../$TMPFILE");
	}

my $lines=`cat $TMPFILE|wc -l`;
	if ("$policy" eq "EMPTY" or "$policy" eq "GOST-ONLY") {
		if ($lines >= 2) { # we allow the SCSV
			print "Empty policy has ciphersuites!\n";
			exit 1;
		}
	} else {
		system("grep \"TLS_EMPTY_RENEGOTIATION_INFO_SCSV\" $TMPFILE >/dev/null 2>&1");
		
		if ($? != 0) {
			print "Could not find TLS_EMPTY_RENEGOTIATION_INFO_SCSV in $policy\n";
			system("cat $TMPFILE");
			exit 1;
		}

if ($lines <= 1) {
			print "Policy $policy has no ciphersuites!\n";
			system("cat $TMPFILE");
			exit 1;
		}
	}
	system("cat $TMPFILE 1>&2");
	unlink($TMPFILE);
}

exit 0;
07070100000036000081A4000003E800000064000000016005CA76000001C3000000000000000000000000000000000000004300000000fedora-crypto-policies-20210118.b21c811/tests/java/CipherList.javaimport java.net.URL;
import java.io.*;
import javax.net.ssl.*;
 
public class CipherList
{
  public static void main(String[] args)
  throws Exception
  {
    SSLContext context = SSLContext.getDefault();
    int i;
    SSLSocketFactory sf = context.getSocketFactory();
    String[] cipherSuites = sf.getDefaultCipherSuites();

for (i=0;i<cipherSuites.length;i++)
    {
      System.out.println(cipherSuites[i]);
    }

System.exit(0);
  }
}

07070100000037000081A4000003E800000064000000016005CA7600000211000000000000000000000000000000000000004400000000fedora-crypto-policies-20210118.b21c811/tests/java/VersionList.javaimport java.net.URL;
import java.io.*;
import javax.net.ssl.*;
 
public class VersionList
{
  public static void main(String[] args)
  throws Exception
  {
    SSLContext context = SSLContext.getDefault();
    int i;
    SSLSocketFactory sf = context.getSocketFactory();
    SSLSocket skt = (SSLSocket)sf.createSocket();
    String[] protocols = skt.getEnabledProtocols();

System.out.println("Protocols:");
    for (i=0;i<protocols.length;i++)
    {
      System.out.println(protocols[i]);
    }

System.exit(0);
  }
}

07070100000038000081ED000003E800000064000000016005CA760000039D000000000000000000000000000000000000003600000000fedora-crypto-policies-20210118.b21c811/tests/krb5.py#!/usr/bin/python3

import sys

# krb5check can be found at:
#     https://github.com/frozencemetery/krb5check
# At a minimum, it verifies that:
#   - no unrecognized sections are specified
#   - no values are overriding each other
#   - libdefaults section is present
#   - permitted_enctypes is specified
#   - no unknown enctypes are specified
#   - no known-broken enctypes are specified
#   - if pkinit_dh_min_bits is specified, it is larger than default
#   - if pkinit_dh_min_bits is specified, it is reasonable

try:
    from krb5check.krb5_conf import parse, check, ACCEPTED_ENCTYPES
except ImportError:
    print("Skipping krb5 test; checker not found!")
    sys.exit(0)

print("Checking the Krb5 configuration")

# Don't verify EMPTY policy
for policy in ["LEGACY", "DEFAULT", "FUTURE", "FIPS"]:
    path = 'tests/outputs/' + policy + '-krb5.txt'

sections = parse(path)
    check(sections, ACCEPTED_ENCTYPES)
07070100000039000081ED000003E800000064000000016005CA760000067D000000000000000000000000000000000000003500000000fedora-crypto-policies-20210118.b21c811/tests/nss.py#!/usr/bin/python3

import ctypes
import ctypes.util
import glob
import os
import shutil
import subprocess
import sys

if shutil.which('nss-policy-check') is None:
    print('nss-policy-check not found, skipping check', file=sys.stderr)
    sys.exit(0)

# Cannot validate with pre-3.59 NSS that doesn't know ECDSA/RSA-PSS/RSA-PKCS
# identifiers yet. Checking for 3.60 because Fedora has reverted the change.
try:
    nss = ctypes.CDLL(ctypes.util.find_library('nss3'))
    if not nss.NSS_VersionCheck(b'3.60'):
        print('Skipping nss-policy-check verification '
              'due to nss being older than 3.60', file=sys.stderr)
        sys.exit(0)
except AttributeError:
    print('Cannot determine nss version with ctypes, hoping for >=3.59',
          file=sys.stderr)

print('Checking the NSS configuration')

for policy_path in glob.glob('tests/outputs/*-nss.txt'):
    policy = os.path.basename(policy_path)[:-len('-nss.txt')]
    print(f'Checking policy {policy}')
    if policy not in ('EMPTY', 'GOST-ONLY'):
        p = subprocess.Popen(['nss-policy-check', policy_path],
                             stdout=subprocess.PIPE,
                             stderr=subprocess.STDOUT)
        output, _ = p.communicate()
        if p.wait():
            print(f'Error in NSS policy for {policy}')
            print(f'NSS policy for {policy}:', file=sys.stderr)
            with open(policy_path) as policy_file:
                shutil.copyfileobj(policy_file, sys.stderr)
                sys.stderr.write('\n')
            print('nss-policy-check error:', file=sys.stderr)
            print(output.decode(), file=sys.stderr)
            sys.exit(1)
0707010000003A000081ED000003E800000064000000016005CA7600000398000000000000000000000000000000000000003900000000fedora-crypto-policies-20210118.b21c811/tests/openssl.pl#!/usr/bin/perl

my $TMPFILE="out-openssl.tmp";

print "Checking the OpenSSL configuration\n";

my $dir = 'tests/outputs';

opendir(DIR, $dir) or die $!;

my @opensslpolicies
    = grep {
        /openssl\./         # has openssl. in name
        && -f "$dir/$_"   # and is a file
    } readdir(DIR);

foreach my $policyfile (@opensslpolicies) {
	my $policy = $policyfile;
	$policy =~ s/-[^-]+$//;

print "Checking policy $policy\n";

my $tmp = do {
		local $/ = undef;
		open my $fh, "<", $dir.'/'.$policyfile
			or die "could not open $file: $!";
		<$fh>;
	};

my %skip_test = map {$_ => 1} ("EMPTY", "GOST-ONLY");

system("openssl ciphers $tmp >$TMPFILE 2>&1") unless exists $skip_test{$policy};
	if ($? != 0) {
		print "Error in OpenSSL policy for $policy\n";

print STDERR "openssl ciphers error:\n";
		system("cat $TMPFILE 1>&2");
		print STDERR "ciphers: $tmp\n";
		exit 1;
	}
	unlink($TMPFILE);
}

exit 0;
0707010000003B000041ED000003E800000064000000026005CA7600000000000000000000000000000000000000000000003600000000fedora-crypto-policies-20210118.b21c811/tests/outputs0707010000003C000081A4000003E800000064000000016005CA760000004B000000000000000000000000000000000000004700000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT-bind.txtdisable-algorithms "." {
RSAMD5;
DSA;
};
disable-ds-digests "." {
GOST;
};
0707010000003D000081A4000003E800000064000000016005CA7600000585000000000000000000000000000000000000004900000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT-gnutls.txt[overrides]
insecure-hash = SHA1
insecure-hash = MD5
insecure-hash = STREEBOG-256
insecure-hash = STREEBOG-512
insecure-hash = GOSTR341194
tls-disabled-mac = MD5
tls-disabled-mac = STREEBOG-256
tls-disabled-mac = STREEBOG-512
tls-disabled-mac = GOST28147-TC26Z-IMIT
tls-disabled-group = GROUP-GC256B
tls-disabled-group = GROUP-GC512A
insecure-sig = RSA-MD5
insecure-sig = RSA-SHA1
insecure-sig = DSA-SHA1
insecure-sig = ECDSA-SHA1
insecure-sig = DSA-SHA224
insecure-sig = DSA-SHA256
insecure-sig = DSA-SHA384
insecure-sig = DSA-SHA512
insecure-sig = GOSTR341012-512
insecure-sig = GOSTR341012-256
insecure-sig = GOSTR341001
insecure-sig-for-cert = rsa-sha1
insecure-sig-for-cert = dsa-sha1
insecure-sig-for-cert = ecdsa-sha1
tls-disabled-cipher = CAMELLIA-256-GCM
tls-disabled-cipher = CAMELLIA-128-GCM
tls-disabled-cipher = CAMELLIA-256-CBC
tls-disabled-cipher = CAMELLIA-128-CBC
tls-disabled-cipher = 3DES-CBC
tls-disabled-cipher = ARCFOUR-128
tls-disabled-cipher = GOST28147-TC26Z-CFB
tls-disabled-cipher = GOST28147-CPA-CFB
tls-disabled-cipher = GOST28147-CPB-CFB
tls-disabled-cipher = GOST28147-CPC-CFB
tls-disabled-cipher = GOST28147-CPD-CFB
tls-disabled-cipher = GOST28147-TC26Z-CNT
tls-disabled-kx = DHE-DSS
tls-disabled-kx = VKO-GOST-12
disabled-version = SSL3.0
disabled-version = TLS1.0
disabled-version = TLS1.1
disabled-version = DTLS1.0
min-verification-profile = medium

[priorities]
SYSTEM=NORMAL
0707010000003E000081A4000003E800000064000000016005CA760000018B000000000000000000000000000000000000004700000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT-java.txtjdk.tls.ephemeralDHKeySize=2048
jdk.certpath.disabledAlgorithms=MD2, SHA1, MD5, DSA, RSA keySize < 2048
jdk.tls.disabledAlgorithms=DH keySize < 2048, SSLv2, SSLv3, TLSv1, TLSv1.1, DHE_DSS, RSA_EXPORT, DHE_DSS_EXPORT, DHE_RSA_EXPORT, DH_DSS_EXPORT, DH_RSA_EXPORT, DH_anon, ECDH_anon, DH_RSA, DH_DSS, ECDH, 3DES_EDE_CBC, DES_CBC, RC4_40, RC4_128, DES40_CBC, RC2, HmacMD5
jdk.tls.legacyAlgorithms=
0707010000003F000081A4000003E800000064000000016005CA76000000B3000000000000000000000000000000000000004700000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT-krb5.txt[libdefaults]
permitted_enctypes = aes256-cts-hmac-sha1-96 aes256-cts-hmac-sha384-192 camellia256-cts-cmac aes128-cts-hmac-sha256-128 aes128-cts-hmac-sha1-96 camellia128-cts-cmac
07070100000040000081A4000003E800000064000000016005CA7600000235000000000000000000000000000000000000004C00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT-libreswan.txtconn %default
	ikev2=insist
	pfs=yes
	ike=aes_gcm256-sha2_512+sha2_256-dh19+dh14+dh31+dh20+dh21+dh15+dh16+dh18,chacha20_poly1305-sha2_512+sha2_256-dh19+dh14+dh31+dh20+dh21+dh15+dh16+dh18,aes256-sha2_512+sha2_256-dh19+dh14+dh31+dh20+dh21+dh15+dh16+dh18,aes_gcm128-sha2_512+sha2_256-dh19+dh14+dh31+dh20+dh21+dh15+dh16+dh18,aes128-sha2_256-dh19+dh14+dh31+dh20+dh21+dh15+dh16+dh18
	esp=aes_gcm256,chacha20_poly1305,aes256-sha2_512+sha1+sha2_256,aes_gcm128,aes128-sha1+sha2_256
	authby=ecdsa-sha2_256,ecdsa-sha2_384,ecdsa-sha2_512,rsa-sha2_256,rsa-sha2_384,rsa-sha2_512
07070100000041000081A4000003E800000064000000016005CA760000048D000000000000000000000000000000000000004900000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT-libssh.txtCiphers aes256-gcm@openssh.com,chacha20-poly1305@openssh.com,aes256-ctr,aes128-gcm@openssh.com,aes128-ctr
MACs hmac-sha2-256-etm@openssh.com,hmac-sha1-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-sha2-256,hmac-sha1,hmac-sha2-512
KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org,ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group14-sha256,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512
HostKeyAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
07070100000042000081A4000003E800000064000000016005CA7600000191000000000000000000000000000000000000004600000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT-nss.txtlibrary=
name=Policy
NSS=flags=policyOnly,moduleDB
config="disallow=ALL allow=HMAC-SHA256:HMAC-SHA1:HMAC-SHA384:HMAC-SHA512:CURVE25519:SECP256R1:SECP384R1:SECP521R1:aes256-gcm:chacha20-poly1305:aes256-cbc:aes128-gcm:aes128-cbc:SHA256:SHA384:SHA512:SHA224:ECDHE-RSA:ECDHE-ECDSA:RSA:DHE-RSA:ECDSA:RSA-PSS:RSA-PKCS:tls-version-min=tls1.2:dtls-version-min=dtls1.2:DH-MIN=2048:DSA-MIN=2048:RSA-MIN=2048"

07070100000043000081A4000003E800000064000000016005CA7600000513000000000000000000000000000000000000004A00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT-openssh.txtCiphers aes256-gcm@openssh.com,chacha20-poly1305@openssh.com,aes256-ctr,aes128-gcm@openssh.com,aes128-ctr
MACs hmac-sha2-256-etm@openssh.com,hmac-sha1-etm@openssh.com,umac-128-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-sha2-256,hmac-sha1,umac-128@openssh.com,hmac-sha2-512
GSSAPIKexAlgorithms gss-curve25519-sha256-,gss-nistp256-sha256-,gss-group14-sha256-,gss-group16-sha512-
KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org,ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group14-sha256,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,sk-ecdsa-sha2-nistp256@openssh.com,sk-ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,sk-ssh-ed25519@openssh.com,sk-ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
CASignatureAlgorithms ecdsa-sha2-nistp256,sk-ecdsa-sha2-nistp256@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,ssh-ed25519,sk-ssh-ed25519@openssh.com,rsa-sha2-256,rsa-sha2-512
07070100000044000081A4000003E800000064000000016005CA76000006F5000000000000000000000000000000000000005000000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT-opensshserver.txtCiphers aes256-gcm@openssh.com,chacha20-poly1305@openssh.com,aes256-ctr,aes128-gcm@openssh.com,aes128-ctr
MACs hmac-sha2-256-etm@openssh.com,hmac-sha1-etm@openssh.com,umac-128-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-sha2-256,hmac-sha1,umac-128@openssh.com,hmac-sha2-512
GSSAPIKexAlgorithms gss-curve25519-sha256-,gss-nistp256-sha256-,gss-group14-sha256-,gss-group16-sha512-
KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org,ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group14-sha256,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512
HostKeyAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,sk-ecdsa-sha2-nistp256@openssh.com,sk-ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,sk-ssh-ed25519@openssh.com,sk-ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,sk-ecdsa-sha2-nistp256@openssh.com,sk-ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,sk-ssh-ed25519@openssh.com,sk-ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
CASignatureAlgorithms ecdsa-sha2-nistp256,sk-ecdsa-sha2-nistp256@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,ssh-ed25519,sk-ssh-ed25519@openssh.com,rsa-sha2-256,rsa-sha2-512
07070100000045000081A4000003E800000064000000016005CA7600000096000000000000000000000000000000000000004A00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT-openssl.txt@SECLEVEL=2:kEECDH:kRSA:kEDH:kPSK:kDHEPSK:kECDHEPSK:kRSAPSK:-aDSS:-3DES:!DES:!RC4:!RC2:!IDEA:-SEED:!eNULL:!aNULL:!MD5:-SHA384:-CAMELLIA:-ARIA:-AESCCM807070100000046000081A4000003E800000064000000016005CA760000023B000000000000000000000000000000000000004D00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT-opensslcnf.txtCipherString = @SECLEVEL=2:kEECDH:kRSA:kEDH:kPSK:kDHEPSK:kECDHEPSK:kRSAPSK:-aDSS:-3DES:!DES:!RC4:!RC2:!IDEA:-SEED:!eNULL:!aNULL:!MD5:-SHA384:-CAMELLIA:-ARIA:-AESCCM8
Ciphersuites = TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:TLS_AES_128_CCM_SHA256
MinProtocol = TLSv1.2
MaxProtocol = TLSv1.3
SignatureAlgorithms = ECDSA+SHA256:ECDSA+SHA384:ECDSA+SHA512:ed25519:ed448:rsa_pss_pss_sha256:rsa_pss_pss_sha384:rsa_pss_pss_sha512:rsa_pss_rsae_sha256:rsa_pss_rsae_sha384:rsa_pss_rsae_sha512:RSA+SHA256:RSA+SHA384:RSA+SHA512:ECDSA+SHA224:RSA+SHA22407070100000047000081A4000003E800000064000000016005CA7600000045000000000000000000000000000000000000004C00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT:GOST-bind.txtdisable-algorithms "." {
RSAMD5;
DSA;
};
disable-ds-digests "." {
};
07070100000048000081A4000003E800000064000000016005CA76000003BA000000000000000000000000000000000000004E00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT:GOST-gnutls.txt[overrides]
insecure-hash = SHA1
insecure-hash = MD5
tls-disabled-mac = MD5
insecure-sig = RSA-MD5
insecure-sig = RSA-SHA1
insecure-sig = DSA-SHA1
insecure-sig = ECDSA-SHA1
insecure-sig = DSA-SHA224
insecure-sig = DSA-SHA256
insecure-sig = DSA-SHA384
insecure-sig = DSA-SHA512
insecure-sig-for-cert = rsa-sha1
insecure-sig-for-cert = dsa-sha1
insecure-sig-for-cert = ecdsa-sha1
tls-disabled-cipher = CAMELLIA-256-GCM
tls-disabled-cipher = CAMELLIA-128-GCM
tls-disabled-cipher = CAMELLIA-256-CBC
tls-disabled-cipher = CAMELLIA-128-CBC
tls-disabled-cipher = 3DES-CBC
tls-disabled-cipher = ARCFOUR-128
tls-disabled-cipher = GOST28147-TC26Z-CFB
tls-disabled-cipher = GOST28147-CPB-CFB
tls-disabled-cipher = GOST28147-CPC-CFB
tls-disabled-cipher = GOST28147-CPD-CFB
tls-disabled-kx = DHE-DSS
disabled-version = SSL3.0
disabled-version = TLS1.0
disabled-version = TLS1.1
disabled-version = DTLS1.0
min-verification-profile = medium

[priorities]
SYSTEM=NORMAL
07070100000049000081A4000003E800000064000000016005CA760000018B000000000000000000000000000000000000004C00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT:GOST-java.txtjdk.tls.ephemeralDHKeySize=2048
jdk.certpath.disabledAlgorithms=MD2, SHA1, MD5, DSA, RSA keySize < 2048
jdk.tls.disabledAlgorithms=DH keySize < 2048, SSLv2, SSLv3, TLSv1, TLSv1.1, DHE_DSS, RSA_EXPORT, DHE_DSS_EXPORT, DHE_RSA_EXPORT, DH_DSS_EXPORT, DH_RSA_EXPORT, DH_anon, ECDH_anon, DH_RSA, DH_DSS, ECDH, 3DES_EDE_CBC, DES_CBC, RC4_40, RC4_128, DES40_CBC, RC2, HmacMD5
jdk.tls.legacyAlgorithms=
0707010000004A000081A4000003E800000064000000016005CA76000000B3000000000000000000000000000000000000004C00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT:GOST-krb5.txt[libdefaults]
permitted_enctypes = aes256-cts-hmac-sha1-96 aes256-cts-hmac-sha384-192 camellia256-cts-cmac aes128-cts-hmac-sha256-128 aes128-cts-hmac-sha1-96 camellia128-cts-cmac
0707010000004B000081A4000003E800000064000000016005CA7600000235000000000000000000000000000000000000005100000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT:GOST-libreswan.txtconn %default
	ikev2=insist
	pfs=yes
	ike=aes_gcm256-sha2_512+sha2_256-dh19+dh14+dh31+dh20+dh21+dh15+dh16+dh18,chacha20_poly1305-sha2_512+sha2_256-dh19+dh14+dh31+dh20+dh21+dh15+dh16+dh18,aes256-sha2_512+sha2_256-dh19+dh14+dh31+dh20+dh21+dh15+dh16+dh18,aes_gcm128-sha2_512+sha2_256-dh19+dh14+dh31+dh20+dh21+dh15+dh16+dh18,aes128-sha2_256-dh19+dh14+dh31+dh20+dh21+dh15+dh16+dh18
	esp=aes_gcm256,chacha20_poly1305,aes256-sha2_512+sha1+sha2_256,aes_gcm128,aes128-sha1+sha2_256
	authby=ecdsa-sha2_256,ecdsa-sha2_384,ecdsa-sha2_512,rsa-sha2_256,rsa-sha2_384,rsa-sha2_512
0707010000004C000081A4000003E800000064000000016005CA760000048D000000000000000000000000000000000000004E00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT:GOST-libssh.txtCiphers aes256-gcm@openssh.com,chacha20-poly1305@openssh.com,aes256-ctr,aes128-gcm@openssh.com,aes128-ctr
MACs hmac-sha2-256-etm@openssh.com,hmac-sha1-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-sha2-256,hmac-sha1,hmac-sha2-512
KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org,ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group14-sha256,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512
HostKeyAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
0707010000004D000081A4000003E800000064000000016005CA7600000191000000000000000000000000000000000000004B00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT:GOST-nss.txtlibrary=
name=Policy
NSS=flags=policyOnly,moduleDB
config="disallow=ALL allow=HMAC-SHA256:HMAC-SHA1:HMAC-SHA384:HMAC-SHA512:CURVE25519:SECP256R1:SECP384R1:SECP521R1:aes256-gcm:chacha20-poly1305:aes256-cbc:aes128-gcm:aes128-cbc:SHA256:SHA384:SHA512:SHA224:ECDHE-RSA:ECDHE-ECDSA:RSA:DHE-RSA:ECDSA:RSA-PSS:RSA-PKCS:tls-version-min=tls1.2:dtls-version-min=dtls1.2:DH-MIN=2048:DSA-MIN=2048:RSA-MIN=2048"

0707010000004E000081A4000003E800000064000000016005CA7600000513000000000000000000000000000000000000004F00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT:GOST-openssh.txtCiphers aes256-gcm@openssh.com,chacha20-poly1305@openssh.com,aes256-ctr,aes128-gcm@openssh.com,aes128-ctr
MACs hmac-sha2-256-etm@openssh.com,hmac-sha1-etm@openssh.com,umac-128-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-sha2-256,hmac-sha1,umac-128@openssh.com,hmac-sha2-512
GSSAPIKexAlgorithms gss-curve25519-sha256-,gss-nistp256-sha256-,gss-group14-sha256-,gss-group16-sha512-
KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org,ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group14-sha256,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,sk-ecdsa-sha2-nistp256@openssh.com,sk-ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,sk-ssh-ed25519@openssh.com,sk-ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
CASignatureAlgorithms ecdsa-sha2-nistp256,sk-ecdsa-sha2-nistp256@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,ssh-ed25519,sk-ssh-ed25519@openssh.com,rsa-sha2-256,rsa-sha2-512
0707010000004F000081A4000003E800000064000000016005CA76000006F5000000000000000000000000000000000000005500000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT:GOST-opensshserver.txtCiphers aes256-gcm@openssh.com,chacha20-poly1305@openssh.com,aes256-ctr,aes128-gcm@openssh.com,aes128-ctr
MACs hmac-sha2-256-etm@openssh.com,hmac-sha1-etm@openssh.com,umac-128-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-sha2-256,hmac-sha1,umac-128@openssh.com,hmac-sha2-512
GSSAPIKexAlgorithms gss-curve25519-sha256-,gss-nistp256-sha256-,gss-group14-sha256-,gss-group16-sha512-
KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org,ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group14-sha256,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512
HostKeyAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,sk-ecdsa-sha2-nistp256@openssh.com,sk-ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,sk-ssh-ed25519@openssh.com,sk-ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,sk-ecdsa-sha2-nistp256@openssh.com,sk-ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,sk-ssh-ed25519@openssh.com,sk-ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
CASignatureAlgorithms ecdsa-sha2-nistp256,sk-ecdsa-sha2-nistp256@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,ssh-ed25519,sk-ssh-ed25519@openssh.com,rsa-sha2-256,rsa-sha2-512
07070100000050000081A4000003E800000064000000016005CA760000009C000000000000000000000000000000000000004F00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT:GOST-openssl.txt@SECLEVEL=2:kGOST:kEECDH:kRSA:kEDH:kPSK:kDHEPSK:kECDHEPSK:kRSAPSK:-aDSS:-3DES:!DES:!RC4:!RC2:!IDEA:-SEED:!eNULL:!aNULL:!MD5:-SHA384:-CAMELLIA:-ARIA:-AESCCM807070100000051000081A4000003E800000064000000016005CA760000025C000000000000000000000000000000000000005200000000fedora-crypto-policies-20210118.b21c811/tests/outputs/DEFAULT:GOST-opensslcnf.txtCipherString = @SECLEVEL=2:kGOST:kEECDH:kRSA:kEDH:kPSK:kDHEPSK:kECDHEPSK:kRSAPSK:-aDSS:-3DES:!DES:!RC4:!RC2:!IDEA:-SEED:!eNULL:!aNULL:!MD5:-SHA384:-CAMELLIA:-ARIA:-AESCCM8
Ciphersuites = GOST2012-GOST8912-GOST8912:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:TLS_AES_128_CCM_SHA256
MinProtocol = TLSv1.2
MaxProtocol = TLSv1.3
SignatureAlgorithms = ECDSA+SHA256:ECDSA+SHA384:ECDSA+SHA512:ed25519:ed448:rsa_pss_pss_sha256:rsa_pss_pss_sha384:rsa_pss_pss_sha512:rsa_pss_rsae_sha256:rsa_pss_rsae_sha384:rsa_pss_rsae_sha512:RSA+SHA256:RSA+SHA384:RSA+SHA512:ECDSA+SHA224:RSA+SHA22407070100000052000081A4000003E800000064000000016005CA760000007B000000000000000000000000000000000000004500000000fedora-crypto-policies-20210118.b21c811/tests/outputs/EMPTY-bind.txtdisable-algorithms "." {
RSAMD5;
RSASHA1;
NSEC3RSASHA1;
DSA;
};
disable-ds-digests "." {
SHA-256;
SHA-384;
SHA-1;
GOST;
};
07070100000053000081A4000003E800000064000000016005CA76000000B2000000000000000000000000000000000000004700000000fedora-crypto-policies-20210118.b21c811/tests/outputs/EMPTY-gnutls.txt[overrides]
insecure-sig-for-cert = rsa-sha1
insecure-sig-for-cert = dsa-sha1
insecure-sig-for-cert = ecdsa-sha1
min-verification-profile = very_weak

[priorities]
SYSTEM=NORMAL
07070100000054000081A4000003E800000064000000016005CA760000031D000000000000000000000000000000000000004500000000fedora-crypto-policies-20210118.b21c811/tests/outputs/EMPTY-java.txtjdk.tls.ephemeralDHKeySize=0
jdk.certpath.disabledAlgorithms=MD2, SHA256, SHA384, SHA512, SHA3_256, SHA3_384, SHA3_512, SHA224, SHA1, MD5, DSA, RSA keySize < 0
jdk.tls.disabledAlgorithms=DH keySize < 0, SSLv2, SSLv3, TLSv1, TLSv1.1, TLSv1.2, RSAPSK, ECDHE, TLS_RSA_WITH_AES_256_CBC_SHA256, TLS_RSA_WITH_AES_256_CBC_SHA, TLS_RSA_WITH_AES_128_CBC_SHA256, TLS_RSA_WITH_AES_128_CBC_SHA, TLS_RSA_WITH_AES_256_GCM_SHA384, TLS_RSA_WITH_AES_128_GCM_SHA256, DHE_RSA, DHE_DSS, RSA_EXPORT, DHE_DSS_EXPORT, DHE_RSA_EXPORT, DH_DSS_EXPORT, DH_RSA_EXPORT, DH_anon, ECDH_anon, DH_RSA, DH_DSS, ECDH, AES_256_GCM, AES_256_CCM, AES_128_GCM, AES_128_CCM, AES_256_CBC, AES_128_CBC, 3DES_EDE_CBC, DES_CBC, RC4_40, RC4_128, DES40_CBC, RC2, HmacSHA1, HmacSHA256, HmacSHA384, HmacSHA512, HmacMD5
jdk.tls.legacyAlgorithms=
07070100000055000081A4000003E800000064000000016005CA7600000024000000000000000000000000000000000000004500000000fedora-crypto-policies-20210118.b21c811/tests/outputs/EMPTY-krb5.txt[libdefaults]
permitted_enctypes = 
07070100000056000081A4000003E800000064000000016005CA7600000017000000000000000000000000000000000000004A00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/EMPTY-libreswan.txtconn %default
	pfs=yes
07070100000057000081A4000003E800000064000000016005CA7600000000000000000000000000000000000000000000004700000000fedora-crypto-policies-20210118.b21c811/tests/outputs/EMPTY-libssh.txt07070100000058000081A4000003E800000064000000016005CA7600000093000000000000000000000000000000000000004400000000fedora-crypto-policies-20210118.b21c811/tests/outputs/EMPTY-nss.txtlibrary=
name=Policy
NSS=flags=policyOnly,moduleDB
config="disallow=ALL allow=tls-version-min=0:dtls-version-min=0:DH-MIN=0:DSA-MIN=0:RSA-MIN=0"

07070100000059000081A4000003E800000064000000016005CA7600000015000000000000000000000000000000000000004800000000fedora-crypto-policies-20210118.b21c811/tests/outputs/EMPTY-openssh.txtGSSAPIKeyExchange no
0707010000005A000081A4000003E800000064000000016005CA7600000015000000000000000000000000000000000000004E00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/EMPTY-opensshserver.txtGSSAPIKeyExchange no
0707010000005B000081A4000003E800000064000000016005CA76000000D6000000000000000000000000000000000000004800000000fedora-crypto-policies-20210118.b21c811/tests/outputs/EMPTY-openssl.txt@SECLEVEL=0:-kPSK:-kDHEPSK:-kECDHEPSK:-kRSAPSK:-kEECDH:-kRSA:-aRSA:-aDSS:-AES256:-AES128:-CHACHA20-POLY1305:-SHA256:-3DES:!DES:!RC4:!RC2:!IDEA:-SEED:!eNULL:!aNULL:-AESCCM:-SHA1:!MD5:-SHA384:-CAMELLIA:-ARIA:-AESCCM80707010000005C000081A4000003E800000064000000016005CA760000011B000000000000000000000000000000000000004B00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/EMPTY-opensslcnf.txtCipherString = @SECLEVEL=0:-kPSK:-kDHEPSK:-kECDHEPSK:-kRSAPSK:-kEECDH:-kRSA:-aRSA:-aDSS:-AES256:-AES128:-CHACHA20-POLY1305:-SHA256:-3DES:!DES:!RC4:!RC2:!IDEA:-SEED:!eNULL:!aNULL:-AESCCM:-SHA1:!MD5:-SHA384:-CAMELLIA:-ARIA:-AESCCM8
Ciphersuites = 
MinProtocol = 
SignatureAlgorithms = 0707010000005D000081A4000003E800000064000000016005CA7600000069000000000000000000000000000000000000004400000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS-bind.txtdisable-algorithms "." {
RSAMD5;
RSASHA1;
NSEC3RSASHA1;
DSA;
};
disable-ds-digests "." {
SHA-1;
GOST;
};
0707010000005E000081A4000003E800000064000000016005CA7600000657000000000000000000000000000000000000004600000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS-gnutls.txt[overrides]
insecure-hash = SHA1
insecure-hash = MD5
insecure-hash = STREEBOG-256
insecure-hash = STREEBOG-512
insecure-hash = GOSTR341194
tls-disabled-mac = MD5
tls-disabled-mac = STREEBOG-256
tls-disabled-mac = STREEBOG-512
tls-disabled-mac = GOST28147-TC26Z-IMIT
tls-disabled-group = GROUP-X25519
tls-disabled-group = GROUP-X448
tls-disabled-group = GROUP-GC256B
tls-disabled-group = GROUP-GC512A
insecure-sig = RSA-MD5
insecure-sig = RSA-SHA1
insecure-sig = DSA-SHA1
insecure-sig = ECDSA-SHA1
insecure-sig = DSA-SHA224
insecure-sig = DSA-SHA256
insecure-sig = DSA-SHA384
insecure-sig = DSA-SHA512
insecure-sig = EDDSA-ED25519
insecure-sig = EDDSA-ED448
insecure-sig = GOSTR341012-512
insecure-sig = GOSTR341012-256
insecure-sig = GOSTR341001
insecure-sig-for-cert = rsa-sha1
insecure-sig-for-cert = dsa-sha1
insecure-sig-for-cert = ecdsa-sha1
tls-disabled-cipher = CHACHA20-POLY1305
tls-disabled-cipher = CAMELLIA-256-GCM
tls-disabled-cipher = CAMELLIA-128-GCM
tls-disabled-cipher = CAMELLIA-256-CBC
tls-disabled-cipher = CAMELLIA-128-CBC
tls-disabled-cipher = 3DES-CBC
tls-disabled-cipher = ARCFOUR-128
tls-disabled-cipher = GOST28147-TC26Z-CFB
tls-disabled-cipher = GOST28147-CPA-CFB
tls-disabled-cipher = GOST28147-CPB-CFB
tls-disabled-cipher = GOST28147-CPC-CFB
tls-disabled-cipher = GOST28147-CPD-CFB
tls-disabled-cipher = GOST28147-TC26Z-CNT
tls-disabled-kx = RSA-PSK
tls-disabled-kx = RSA
tls-disabled-kx = DHE-DSS
tls-disabled-kx = VKO-GOST-12
disabled-version = SSL3.0
disabled-version = TLS1.0
disabled-version = TLS1.1
disabled-version = DTLS1.0
min-verification-profile = medium

[priorities]
SYSTEM=NORMAL
0707010000005F000081A4000003E800000064000000016005CA7600000253000000000000000000000000000000000000004400000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS-java.txtjdk.tls.ephemeralDHKeySize=2048
jdk.certpath.disabledAlgorithms=MD2, SHA1, MD5, DSA, RSA keySize < 2048
jdk.tls.disabledAlgorithms=DH keySize < 2048, SSLv2, SSLv3, TLSv1, TLSv1.1, RSAPSK, TLS_RSA_WITH_AES_256_CBC_SHA256, TLS_RSA_WITH_AES_256_CBC_SHA, TLS_RSA_WITH_AES_128_CBC_SHA256, TLS_RSA_WITH_AES_128_CBC_SHA, TLS_RSA_WITH_AES_256_GCM_SHA384, TLS_RSA_WITH_AES_128_GCM_SHA256, DHE_DSS, RSA_EXPORT, DHE_DSS_EXPORT, DHE_RSA_EXPORT, DH_DSS_EXPORT, DH_RSA_EXPORT, DH_anon, ECDH_anon, DH_RSA, DH_DSS, ECDH, 3DES_EDE_CBC, DES_CBC, RC4_40, RC4_128, DES40_CBC, RC2, HmacMD5
jdk.tls.legacyAlgorithms=
07070100000060000081A4000003E800000064000000016005CA7600000089000000000000000000000000000000000000004400000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS-krb5.txt[libdefaults]
permitted_enctypes = aes256-cts-hmac-sha1-96 aes256-cts-hmac-sha384-192 aes128-cts-hmac-sha256-128 aes128-cts-hmac-sha1-96
07070100000061000081A4000003E800000064000000016005CA76000001C3000000000000000000000000000000000000004900000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS-libreswan.txtconn %default
	ikev2=insist
	pfs=yes
	ike=aes_gcm256-sha2_512+sha2_256-dh19+dh14+dh20+dh21+dh15+dh16+dh18,aes256-sha2_512+sha2_256-dh19+dh14+dh20+dh21+dh15+dh16+dh18,aes_gcm128-sha2_512+sha2_256-dh19+dh14+dh20+dh21+dh15+dh16+dh18,aes128-sha2_256-dh19+dh14+dh20+dh21+dh15+dh16+dh18
	esp=aes_gcm256,aes256-sha2_512+sha1+sha2_256,aes_gcm128,aes128-sha1+sha2_256
	authby=ecdsa-sha2_256,ecdsa-sha2_384,ecdsa-sha2_512,rsa-sha2_256,rsa-sha2_384,rsa-sha2_512
07070100000062000081A4000003E800000064000000016005CA76000003E6000000000000000000000000000000000000004600000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS-libssh.txtCiphers aes256-gcm@openssh.com,aes256-ctr,aes128-gcm@openssh.com,aes128-ctr
MACs hmac-sha2-256-etm@openssh.com,hmac-sha1-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-sha2-256,hmac-sha1,hmac-sha2-512
KexAlgorithms ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group14-sha256,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512
HostKeyAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
07070100000063000081A4000003E800000064000000016005CA7600000170000000000000000000000000000000000000004300000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS-nss.txtlibrary=
name=Policy
NSS=flags=policyOnly,moduleDB
config="disallow=ALL allow=HMAC-SHA256:HMAC-SHA1:HMAC-SHA384:HMAC-SHA512:SECP256R1:SECP384R1:SECP521R1:aes256-gcm:aes256-cbc:aes128-gcm:aes128-cbc:SHA256:SHA384:SHA512:SHA224:ECDHE-RSA:ECDHE-ECDSA:DHE-RSA:ECDSA:RSA-PSS:RSA-PKCS:tls-version-min=tls1.2:dtls-version-min=dtls1.2:DH-MIN=2048:DSA-MIN=2048:RSA-MIN=2048"

07070100000064000081A4000003E800000064000000016005CA7600000340000000000000000000000000000000000000004700000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS-openssh.txtCiphers aes256-gcm@openssh.com,aes256-ctr,aes128-gcm@openssh.com,aes128-ctr
MACs hmac-sha2-256-etm@openssh.com,hmac-sha1-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-sha2-256,hmac-sha1,hmac-sha2-512
GSSAPIKeyExchange no
KexAlgorithms ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group14-sha256,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
CASignatureAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,rsa-sha2-256,rsa-sha2-512
07070100000065000081A4000003E800000064000000016005CA7600000467000000000000000000000000000000000000004D00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS-opensshserver.txtCiphers aes256-gcm@openssh.com,aes256-ctr,aes128-gcm@openssh.com,aes128-ctr
MACs hmac-sha2-256-etm@openssh.com,hmac-sha1-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-sha2-256,hmac-sha1,hmac-sha2-512
GSSAPIKeyExchange no
KexAlgorithms ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group14-sha256,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512
HostKeyAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
CASignatureAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,rsa-sha2-256,rsa-sha2-512
07070100000066000081A4000003E800000064000000016005CA76000000AB000000000000000000000000000000000000004700000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS-openssl.txt@SECLEVEL=2:kEECDH:kEDH:kPSK:kDHEPSK:kECDHEPSK:-kRSAPSK:-kRSA:-aDSS:-CHACHA20-POLY1305:-3DES:!DES:!RC4:!RC2:!IDEA:-SEED:!eNULL:!aNULL:!MD5:-SHA384:-CAMELLIA:-ARIA:-AESCCM807070100000067000081A4000003E800000064000000016005CA7600000225000000000000000000000000000000000000004A00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS-opensslcnf.txtCipherString = @SECLEVEL=2:kEECDH:kEDH:kPSK:kDHEPSK:kECDHEPSK:-kRSAPSK:-kRSA:-aDSS:-CHACHA20-POLY1305:-3DES:!DES:!RC4:!RC2:!IDEA:-SEED:!eNULL:!aNULL:!MD5:-SHA384:-CAMELLIA:-ARIA:-AESCCM8
Ciphersuites = TLS_AES_256_GCM_SHA384:TLS_AES_128_GCM_SHA256:TLS_AES_128_CCM_SHA256
MinProtocol = TLSv1.2
MaxProtocol = TLSv1.3
SignatureAlgorithms = ECDSA+SHA256:ECDSA+SHA384:ECDSA+SHA512:rsa_pss_pss_sha256:rsa_pss_pss_sha384:rsa_pss_pss_sha512:rsa_pss_rsae_sha256:rsa_pss_rsae_sha384:rsa_pss_rsae_sha512:RSA+SHA256:RSA+SHA384:RSA+SHA512:ECDSA+SHA224:RSA+SHA22407070100000068000081A4000003E800000064000000016005CA7600000069000000000000000000000000000000000000004F00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:ECDHE-ONLY-bind.txtdisable-algorithms "." {
RSAMD5;
RSASHA1;
NSEC3RSASHA1;
DSA;
};
disable-ds-digests "." {
SHA-1;
GOST;
};
07070100000069000081A4000003E800000064000000016005CA760000075A000000000000000000000000000000000000005100000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:ECDHE-ONLY-gnutls.txt[overrides]
insecure-hash = SHA1
insecure-hash = MD5
insecure-hash = STREEBOG-256
insecure-hash = STREEBOG-512
insecure-hash = GOSTR341194
tls-disabled-mac = MD5
tls-disabled-mac = STREEBOG-256
tls-disabled-mac = STREEBOG-512
tls-disabled-mac = GOST28147-TC26Z-IMIT
tls-disabled-group = GROUP-X25519
tls-disabled-group = GROUP-X448
tls-disabled-group = GROUP-FFDHE2048
tls-disabled-group = GROUP-FFDHE3072
tls-disabled-group = GROUP-FFDHE4096
tls-disabled-group = GROUP-FFDHE6144
tls-disabled-group = GROUP-FFDHE8192
tls-disabled-group = GROUP-GC256B
tls-disabled-group = GROUP-GC512A
insecure-sig = RSA-MD5
insecure-sig = RSA-SHA1
insecure-sig = DSA-SHA1
insecure-sig = ECDSA-SHA1
insecure-sig = DSA-SHA224
insecure-sig = DSA-SHA256
insecure-sig = DSA-SHA384
insecure-sig = DSA-SHA512
insecure-sig = EDDSA-ED25519
insecure-sig = EDDSA-ED448
insecure-sig = GOSTR341012-512
insecure-sig = GOSTR341012-256
insecure-sig = GOSTR341001
insecure-sig-for-cert = rsa-sha1
insecure-sig-for-cert = dsa-sha1
insecure-sig-for-cert = ecdsa-sha1
tls-disabled-cipher = CHACHA20-POLY1305
tls-disabled-cipher = CAMELLIA-256-GCM
tls-disabled-cipher = CAMELLIA-128-GCM
tls-disabled-cipher = CAMELLIA-256-CBC
tls-disabled-cipher = CAMELLIA-128-CBC
tls-disabled-cipher = 3DES-CBC
tls-disabled-cipher = ARCFOUR-128
tls-disabled-cipher = GOST28147-TC26Z-CFB
tls-disabled-cipher = GOST28147-CPA-CFB
tls-disabled-cipher = GOST28147-CPB-CFB
tls-disabled-cipher = GOST28147-CPC-CFB
tls-disabled-cipher = GOST28147-CPD-CFB
tls-disabled-cipher = GOST28147-TC26Z-CNT
tls-disabled-kx = PSK
tls-disabled-kx = DHE-PSK
tls-disabled-kx = RSA-PSK
tls-disabled-kx = RSA
tls-disabled-kx = DHE-RSA
tls-disabled-kx = DHE-DSS
tls-disabled-kx = VKO-GOST-12
disabled-version = SSL3.0
disabled-version = TLS1.0
disabled-version = TLS1.1
disabled-version = DTLS1.0
min-verification-profile = medium

[priorities]
SYSTEM=NORMAL
0707010000006A000081A4000003E800000064000000016005CA760000025C000000000000000000000000000000000000004F00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:ECDHE-ONLY-java.txtjdk.tls.ephemeralDHKeySize=2048
jdk.certpath.disabledAlgorithms=MD2, SHA1, MD5, DSA, RSA keySize < 2048
jdk.tls.disabledAlgorithms=DH keySize < 2048, SSLv2, SSLv3, TLSv1, TLSv1.1, RSAPSK, TLS_RSA_WITH_AES_256_CBC_SHA256, TLS_RSA_WITH_AES_256_CBC_SHA, TLS_RSA_WITH_AES_128_CBC_SHA256, TLS_RSA_WITH_AES_128_CBC_SHA, TLS_RSA_WITH_AES_256_GCM_SHA384, TLS_RSA_WITH_AES_128_GCM_SHA256, DHE_RSA, DHE_DSS, RSA_EXPORT, DHE_DSS_EXPORT, DHE_RSA_EXPORT, DH_DSS_EXPORT, DH_RSA_EXPORT, DH_anon, ECDH_anon, DH_RSA, DH_DSS, ECDH, 3DES_EDE_CBC, DES_CBC, RC4_40, RC4_128, DES40_CBC, RC2, HmacMD5
jdk.tls.legacyAlgorithms=
0707010000006B000081A4000003E800000064000000016005CA7600000089000000000000000000000000000000000000004F00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:ECDHE-ONLY-krb5.txt[libdefaults]
permitted_enctypes = aes256-cts-hmac-sha1-96 aes256-cts-hmac-sha384-192 aes128-cts-hmac-sha256-128 aes128-cts-hmac-sha1-96
0707010000006C000081A4000003E800000064000000016005CA7600000173000000000000000000000000000000000000005400000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:ECDHE-ONLY-libreswan.txtconn %default
	ikev2=insist
	pfs=yes
	ike=aes_gcm256-sha2_512+sha2_256-dh19+dh20+dh21,aes256-sha2_512+sha2_256-dh19+dh20+dh21,aes_gcm128-sha2_512+sha2_256-dh19+dh20+dh21,aes128-sha2_256-dh19+dh20+dh21
	esp=aes_gcm256,aes256-sha2_512+sha1+sha2_256,aes_gcm128,aes128-sha1+sha2_256
	authby=ecdsa-sha2_256,ecdsa-sha2_384,ecdsa-sha2_512,rsa-sha2_256,rsa-sha2_384,rsa-sha2_512
0707010000006D000081A4000003E800000064000000016005CA7600000367000000000000000000000000000000000000005100000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:ECDHE-ONLY-libssh.txtCiphers aes256-gcm@openssh.com,aes256-ctr,aes128-gcm@openssh.com,aes128-ctr
MACs hmac-sha2-256-etm@openssh.com,hmac-sha1-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-sha2-256,hmac-sha1,hmac-sha2-512
KexAlgorithms ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521
HostKeyAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
0707010000006E000081A4000003E800000064000000016005CA7600000168000000000000000000000000000000000000004E00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:ECDHE-ONLY-nss.txtlibrary=
name=Policy
NSS=flags=policyOnly,moduleDB
config="disallow=ALL allow=HMAC-SHA256:HMAC-SHA1:HMAC-SHA384:HMAC-SHA512:SECP256R1:SECP384R1:SECP521R1:aes256-gcm:aes256-cbc:aes128-gcm:aes128-cbc:SHA256:SHA384:SHA512:SHA224:ECDHE-RSA:ECDHE-ECDSA:ECDSA:RSA-PSS:RSA-PKCS:tls-version-min=tls1.2:dtls-version-min=dtls1.2:DH-MIN=2048:DSA-MIN=2048:RSA-MIN=2048"

0707010000006F000081A4000003E800000064000000016005CA76000002C1000000000000000000000000000000000000005200000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:ECDHE-ONLY-openssh.txtCiphers aes256-gcm@openssh.com,aes256-ctr,aes128-gcm@openssh.com,aes128-ctr
MACs hmac-sha2-256-etm@openssh.com,hmac-sha1-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-sha2-256,hmac-sha1,hmac-sha2-512
GSSAPIKeyExchange no
KexAlgorithms ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
CASignatureAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,rsa-sha2-256,rsa-sha2-512
07070100000070000081A4000003E800000064000000016005CA76000003E8000000000000000000000000000000000000005800000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:ECDHE-ONLY-opensshserver.txtCiphers aes256-gcm@openssh.com,aes256-ctr,aes128-gcm@openssh.com,aes128-ctr
MACs hmac-sha2-256-etm@openssh.com,hmac-sha1-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-sha2-256,hmac-sha1,hmac-sha2-512
GSSAPIKeyExchange no
KexAlgorithms ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521
HostKeyAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
CASignatureAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,rsa-sha2-256,rsa-sha2-512
07070100000071000081A4000003E800000064000000016005CA76000000AE000000000000000000000000000000000000005200000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:ECDHE-ONLY-openssl.txt@SECLEVEL=2:kEECDH:kECDHEPSK:-kPSK:-kDHEPSK:-kRSAPSK:-kRSA:-aRSA:-aDSS:-CHACHA20-POLY1305:-3DES:!DES:!RC4:!RC2:!IDEA:-SEED:!eNULL:!aNULL:!MD5:-SHA384:-CAMELLIA:-ARIA:-AESCCM807070100000072000081A4000003E800000064000000016005CA7600000228000000000000000000000000000000000000005500000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:ECDHE-ONLY-opensslcnf.txtCipherString = @SECLEVEL=2:kEECDH:kECDHEPSK:-kPSK:-kDHEPSK:-kRSAPSK:-kRSA:-aRSA:-aDSS:-CHACHA20-POLY1305:-3DES:!DES:!RC4:!RC2:!IDEA:-SEED:!eNULL:!aNULL:!MD5:-SHA384:-CAMELLIA:-ARIA:-AESCCM8
Ciphersuites = TLS_AES_256_GCM_SHA384:TLS_AES_128_GCM_SHA256:TLS_AES_128_CCM_SHA256
MinProtocol = TLSv1.2
MaxProtocol = TLSv1.3
SignatureAlgorithms = ECDSA+SHA256:ECDSA+SHA384:ECDSA+SHA512:rsa_pss_pss_sha256:rsa_pss_pss_sha384:rsa_pss_pss_sha512:rsa_pss_rsae_sha256:rsa_pss_rsae_sha384:rsa_pss_rsae_sha512:RSA+SHA256:RSA+SHA384:RSA+SHA512:ECDSA+SHA224:RSA+SHA22407070100000073000081A4000003E800000064000000016005CA7600000069000000000000000000000000000000000000004900000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:OSPP-bind.txtdisable-algorithms "." {
RSAMD5;
RSASHA1;
NSEC3RSASHA1;
DSA;
};
disable-ds-digests "." {
SHA-1;
GOST;
};
07070100000074000081A4000003E800000064000000016005CA7600000700000000000000000000000000000000000000004B00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:OSPP-gnutls.txt[overrides]
insecure-hash = SHA3-256
insecure-hash = SHA3-384
insecure-hash = SHA3-512
insecure-hash = SHA1
insecure-hash = MD5
insecure-hash = STREEBOG-256
insecure-hash = STREEBOG-512
insecure-hash = GOSTR341194
tls-disabled-mac = MD5
tls-disabled-mac = STREEBOG-256
tls-disabled-mac = STREEBOG-512
tls-disabled-mac = GOST28147-TC26Z-IMIT
tls-disabled-group = GROUP-X25519
tls-disabled-group = GROUP-X448
tls-disabled-group = GROUP-GC256B
tls-disabled-group = GROUP-GC512A
insecure-sig = RSA-MD5
insecure-sig = RSA-SHA1
insecure-sig = DSA-SHA1
insecure-sig = ECDSA-SHA1
insecure-sig = DSA-SHA224
insecure-sig = DSA-SHA256
insecure-sig = DSA-SHA384
insecure-sig = DSA-SHA512
insecure-sig = EDDSA-ED25519
insecure-sig = EDDSA-ED448
insecure-sig = GOSTR341012-512
insecure-sig = GOSTR341012-256
insecure-sig = GOSTR341001
insecure-sig-for-cert = rsa-sha1
insecure-sig-for-cert = dsa-sha1
insecure-sig-for-cert = ecdsa-sha1
tls-disabled-cipher = AES-256-CCM
tls-disabled-cipher = AES-128-CCM
tls-disabled-cipher = CHACHA20-POLY1305
tls-disabled-cipher = CAMELLIA-256-GCM
tls-disabled-cipher = CAMELLIA-128-GCM
tls-disabled-cipher = CAMELLIA-256-CBC
tls-disabled-cipher = CAMELLIA-128-CBC
tls-disabled-cipher = 3DES-CBC
tls-disabled-cipher = ARCFOUR-128
tls-disabled-cipher = GOST28147-TC26Z-CFB
tls-disabled-cipher = GOST28147-CPA-CFB
tls-disabled-cipher = GOST28147-CPB-CFB
tls-disabled-cipher = GOST28147-CPC-CFB
tls-disabled-cipher = GOST28147-CPD-CFB
tls-disabled-cipher = GOST28147-TC26Z-CNT
tls-disabled-kx = RSA-PSK
tls-disabled-kx = RSA
tls-disabled-kx = DHE-DSS
tls-disabled-kx = VKO-GOST-12
disabled-version = SSL3.0
disabled-version = TLS1.0
disabled-version = TLS1.1
disabled-version = TLS1.3
disabled-version = DTLS1.0
min-verification-profile = medium

[priorities]
SYSTEM=NORMAL
07070100000075000081A4000003E800000064000000016005CA7600000293000000000000000000000000000000000000004900000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:OSPP-java.txtjdk.tls.ephemeralDHKeySize=2048
jdk.certpath.disabledAlgorithms=MD2, SHA3_256, SHA3_384, SHA3_512, SHA224, SHA1, MD5, DSA, RSA keySize < 2048
jdk.tls.disabledAlgorithms=DH keySize < 2048, SSLv2, SSLv3, TLSv1, TLSv1.1, RSAPSK, TLS_RSA_WITH_AES_256_CBC_SHA256, TLS_RSA_WITH_AES_256_CBC_SHA, TLS_RSA_WITH_AES_128_CBC_SHA256, TLS_RSA_WITH_AES_128_CBC_SHA, TLS_RSA_WITH_AES_256_GCM_SHA384, TLS_RSA_WITH_AES_128_GCM_SHA256, DHE_DSS, RSA_EXPORT, DHE_DSS_EXPORT, DHE_RSA_EXPORT, DH_DSS_EXPORT, DH_RSA_EXPORT, DH_anon, ECDH_anon, DH_RSA, DH_DSS, ECDH, AES_256_CCM, AES_128_CCM, 3DES_EDE_CBC, DES_CBC, RC4_40, RC4_128, DES40_CBC, RC2, HmacMD5
jdk.tls.legacyAlgorithms=
07070100000076000081A4000003E800000064000000016005CA7600000089000000000000000000000000000000000000004900000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:OSPP-krb5.txt[libdefaults]
permitted_enctypes = aes256-cts-hmac-sha1-96 aes256-cts-hmac-sha384-192 aes128-cts-hmac-sha256-128 aes128-cts-hmac-sha1-96
07070100000077000081A4000003E800000064000000016005CA76000001C3000000000000000000000000000000000000004E00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:OSPP-libreswan.txtconn %default
	ikev2=insist
	pfs=yes
	ike=aes_gcm256-sha2_512+sha2_256-dh19+dh14+dh20+dh21+dh15+dh16+dh18,aes256-sha2_512+sha2_256-dh19+dh14+dh20+dh21+dh15+dh16+dh18,aes_gcm128-sha2_512+sha2_256-dh19+dh14+dh20+dh21+dh15+dh16+dh18,aes128-sha2_256-dh19+dh14+dh20+dh21+dh15+dh16+dh18
	esp=aes_gcm256,aes256-sha2_512+sha1+sha2_256,aes_gcm128,aes128-sha1+sha2_256
	authby=ecdsa-sha2_256,ecdsa-sha2_384,ecdsa-sha2_512,rsa-sha2_256,rsa-sha2_384,rsa-sha2_512
07070100000078000081A4000003E800000064000000016005CA760000032F000000000000000000000000000000000000004B00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:OSPP-libssh.txtCiphers aes256-gcm@openssh.com,aes256-ctr,aes128-gcm@openssh.com,aes128-ctr
MACs hmac-sha2-256,hmac-sha1,hmac-sha2-512
KexAlgorithms ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group14-sha256
HostKeyAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
07070100000079000081A4000003E800000064000000016005CA7600000169000000000000000000000000000000000000004800000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:OSPP-nss.txtlibrary=
name=Policy
NSS=flags=policyOnly,moduleDB
config="disallow=ALL allow=HMAC-SHA256:HMAC-SHA1:HMAC-SHA384:HMAC-SHA512:SECP256R1:SECP384R1:SECP521R1:aes256-gcm:aes256-cbc:aes128-gcm:aes128-cbc:SHA256:SHA384:SHA512:ECDHE-RSA:ECDHE-ECDSA:DHE-RSA:ECDSA:RSA-PSS:RSA-PKCS:tls-version-min=tls1.2:dtls-version-min=dtls1.2:DH-MIN=2048:DSA-MIN=2048:RSA-MIN=2048"

0707010000007A000081A4000003E800000064000000016005CA76000001CA000000000000000000000000000000000000004C00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:OSPP-openssh.txtCiphers aes256-gcm@openssh.com,aes256-ctr,aes128-gcm@openssh.com,aes128-ctr
MACs hmac-sha2-256,hmac-sha1,hmac-sha2-512
GSSAPIKeyExchange no
KexAlgorithms ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group14-sha256
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,rsa-sha2-256,rsa-sha2-512
CASignatureAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,rsa-sha2-256,rsa-sha2-512
0707010000007B000081A4000003E800000064000000016005CA7600000232000000000000000000000000000000000000005200000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:OSPP-opensshserver.txtCiphers aes256-gcm@openssh.com,aes256-ctr,aes128-gcm@openssh.com,aes128-ctr
MACs hmac-sha2-256,hmac-sha1,hmac-sha2-512
GSSAPIKeyExchange no
KexAlgorithms ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group14-sha256
HostKeyAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,rsa-sha2-256,rsa-sha2-512
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,rsa-sha2-256,rsa-sha2-512
CASignatureAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,rsa-sha2-256,rsa-sha2-512
0707010000007C000081A4000003E800000064000000016005CA76000000B3000000000000000000000000000000000000004C00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:OSPP-openssl.txt@SECLEVEL=2:kEECDH:kEDH:kPSK:kDHEPSK:kECDHEPSK:-kRSAPSK:-kRSA:-aDSS:-CHACHA20-POLY1305:-3DES:!DES:!RC4:!RC2:!IDEA:-SEED:!eNULL:!aNULL:-AESCCM:!MD5:-SHA384:-CAMELLIA:-ARIA:-AESCCM80707010000007D000081A4000003E800000064000000016005CA7600000216000000000000000000000000000000000000004F00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FIPS:OSPP-opensslcnf.txtCipherString = @SECLEVEL=2:kEECDH:kEDH:kPSK:kDHEPSK:kECDHEPSK:-kRSAPSK:-kRSA:-aDSS:-CHACHA20-POLY1305:-3DES:!DES:!RC4:!RC2:!IDEA:-SEED:!eNULL:!aNULL:-AESCCM:!MD5:-SHA384:-CAMELLIA:-ARIA:-AESCCM8
Ciphersuites = TLS_AES_256_GCM_SHA384:TLS_AES_128_GCM_SHA256
MinProtocol = TLSv1.2
MaxProtocol = TLSv1.2
SignatureAlgorithms = ECDSA+SHA256:ECDSA+SHA384:ECDSA+SHA512:rsa_pss_pss_sha256:rsa_pss_pss_sha384:rsa_pss_pss_sha512:rsa_pss_rsae_sha256:rsa_pss_rsae_sha384:rsa_pss_rsae_sha512:RSA+SHA256:RSA+SHA384:RSA+SHA512:ECDSA+SHA224:RSA+SHA2240707010000007E000081A4000003E800000064000000016005CA7600000069000000000000000000000000000000000000004600000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FUTURE-bind.txtdisable-algorithms "." {
RSAMD5;
RSASHA1;
NSEC3RSASHA1;
DSA;
};
disable-ds-digests "." {
SHA-1;
GOST;
};
0707010000007F000081A4000003E800000064000000016005CA76000006AE000000000000000000000000000000000000004800000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FUTURE-gnutls.txt[overrides]
insecure-hash = SHA1
insecure-hash = MD5
insecure-hash = STREEBOG-256
insecure-hash = STREEBOG-512
insecure-hash = GOSTR341194
tls-disabled-mac = SHA1
tls-disabled-mac = MD5
tls-disabled-mac = STREEBOG-256
tls-disabled-mac = STREEBOG-512
tls-disabled-mac = GOST28147-TC26Z-IMIT
tls-disabled-group = GROUP-FFDHE2048
tls-disabled-group = GROUP-GC256B
tls-disabled-group = GROUP-GC512A
insecure-sig = RSA-MD5
insecure-sig = RSA-SHA1
insecure-sig = DSA-SHA1
insecure-sig = ECDSA-SHA1
insecure-sig = RSA-SHA224
insecure-sig = DSA-SHA224
insecure-sig = ECDSA-SHA224
insecure-sig = DSA-SHA256
insecure-sig = DSA-SHA384
insecure-sig = DSA-SHA512
insecure-sig = GOSTR341012-512
insecure-sig = GOSTR341012-256
insecure-sig = GOSTR341001
insecure-sig-for-cert = rsa-sha1
insecure-sig-for-cert = dsa-sha1
insecure-sig-for-cert = ecdsa-sha1
tls-disabled-cipher = AES-128-GCM
tls-disabled-cipher = AES-128-CCM
tls-disabled-cipher = CAMELLIA-256-GCM
tls-disabled-cipher = CAMELLIA-128-GCM
tls-disabled-cipher = AES-256-CBC
tls-disabled-cipher = AES-128-CBC
tls-disabled-cipher = CAMELLIA-256-CBC
tls-disabled-cipher = CAMELLIA-128-CBC
tls-disabled-cipher = 3DES-CBC
tls-disabled-cipher = ARCFOUR-128
tls-disabled-cipher = GOST28147-TC26Z-CFB
tls-disabled-cipher = GOST28147-CPA-CFB
tls-disabled-cipher = GOST28147-CPB-CFB
tls-disabled-cipher = GOST28147-CPC-CFB
tls-disabled-cipher = GOST28147-CPD-CFB
tls-disabled-cipher = GOST28147-TC26Z-CNT
tls-disabled-kx = RSA-PSK
tls-disabled-kx = RSA
tls-disabled-kx = DHE-DSS
tls-disabled-kx = VKO-GOST-12
disabled-version = SSL3.0
disabled-version = TLS1.0
disabled-version = TLS1.1
disabled-version = DTLS1.0
min-verification-profile = high

[priorities]
SYSTEM=NORMAL
07070100000080000081A4000003E800000064000000016005CA7600000299000000000000000000000000000000000000004600000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FUTURE-java.txtjdk.tls.ephemeralDHKeySize=3072
jdk.certpath.disabledAlgorithms=MD2, SHA224, SHA1, MD5, DSA, RSA keySize < 3072
jdk.tls.disabledAlgorithms=DH keySize < 3072, SSLv2, SSLv3, TLSv1, TLSv1.1, RSAPSK, TLS_RSA_WITH_AES_256_CBC_SHA256, TLS_RSA_WITH_AES_256_CBC_SHA, TLS_RSA_WITH_AES_128_CBC_SHA256, TLS_RSA_WITH_AES_128_CBC_SHA, TLS_RSA_WITH_AES_256_GCM_SHA384, TLS_RSA_WITH_AES_128_GCM_SHA256, DHE_DSS, RSA_EXPORT, DHE_DSS_EXPORT, DHE_RSA_EXPORT, DH_DSS_EXPORT, DH_RSA_EXPORT, DH_anon, ECDH_anon, DH_RSA, DH_DSS, ECDH, AES_128_GCM, AES_128_CCM, AES_256_CBC, AES_128_CBC, 3DES_EDE_CBC, DES_CBC, RC4_40, RC4_128, DES40_CBC, RC2, HmacSHA1, HmacMD5
jdk.tls.legacyAlgorithms=
07070100000081000081A4000003E800000064000000016005CA760000006B000000000000000000000000000000000000004600000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FUTURE-krb5.txt[libdefaults]
permitted_enctypes = aes256-cts-hmac-sha384-192 camellia256-cts-cmac
pkinit_dh_min_bits=4096
07070100000082000081A4000003E800000064000000016005CA7600000184000000000000000000000000000000000000004B00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FUTURE-libreswan.txtconn %default
	ikev2=insist
	pfs=yes
	ike=aes_gcm256-sha2_512+sha2_256-dh19+dh31+dh20+dh21+dh15+dh16+dh18,chacha20_poly1305-sha2_512+sha2_256-dh19+dh31+dh20+dh21+dh15+dh16+dh18,aes256-sha2_512+sha2_256-dh19+dh31+dh20+dh21+dh15+dh16+dh18
	esp=aes_gcm256,chacha20_poly1305,aes256-sha2_512+sha2_256
	authby=ecdsa-sha2_256,ecdsa-sha2_384,ecdsa-sha2_512,rsa-sha2_256,rsa-sha2_384,rsa-sha2_512
07070100000083000081A4000003E800000064000000016005CA7600000429000000000000000000000000000000000000004800000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FUTURE-libssh.txtCiphers aes256-gcm@openssh.com,chacha20-poly1305@openssh.com,aes256-ctr
MACs hmac-sha2-256-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-sha2-256,hmac-sha2-512
KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org,ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512
HostKeyAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
07070100000084000081A4000003E800000064000000016005CA760000015B000000000000000000000000000000000000004500000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FUTURE-nss.txtlibrary=
name=Policy
NSS=flags=policyOnly,moduleDB
config="disallow=ALL allow=HMAC-SHA256:HMAC-SHA384:HMAC-SHA512:CURVE25519:SECP256R1:SECP384R1:SECP521R1:aes256-gcm:chacha20-poly1305:SHA256:SHA384:SHA512:ECDHE-RSA:ECDHE-ECDSA:DHE-RSA:ECDSA:RSA-PSS:RSA-PKCS:tls-version-min=tls1.2:dtls-version-min=dtls1.2:DH-MIN=3072:DSA-MIN=3072:RSA-MIN=3072"

07070100000085000081A4000003E800000064000000016005CA760000049B000000000000000000000000000000000000004900000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FUTURE-openssh.txtCiphers aes256-gcm@openssh.com,chacha20-poly1305@openssh.com,aes256-ctr
MACs hmac-sha2-256-etm@openssh.com,umac-128-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-sha2-256,umac-128@openssh.com,hmac-sha2-512
GSSAPIKexAlgorithms gss-curve25519-sha256-,gss-nistp256-sha256-,gss-group16-sha512-
KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org,ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,sk-ecdsa-sha2-nistp256@openssh.com,sk-ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,sk-ssh-ed25519@openssh.com,sk-ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
CASignatureAlgorithms ecdsa-sha2-nistp256,sk-ecdsa-sha2-nistp256@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,ssh-ed25519,sk-ssh-ed25519@openssh.com,rsa-sha2-256,rsa-sha2-512
07070100000086000081A4000003E800000064000000016005CA760000067D000000000000000000000000000000000000004F00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FUTURE-opensshserver.txtCiphers aes256-gcm@openssh.com,chacha20-poly1305@openssh.com,aes256-ctr
MACs hmac-sha2-256-etm@openssh.com,umac-128-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-sha2-256,umac-128@openssh.com,hmac-sha2-512
GSSAPIKexAlgorithms gss-curve25519-sha256-,gss-nistp256-sha256-,gss-group16-sha512-
KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org,ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512
HostKeyAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,sk-ecdsa-sha2-nistp256@openssh.com,sk-ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,sk-ssh-ed25519@openssh.com,sk-ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,sk-ecdsa-sha2-nistp256@openssh.com,sk-ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,sk-ssh-ed25519@openssh.com,sk-ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com
CASignatureAlgorithms ecdsa-sha2-nistp256,sk-ecdsa-sha2-nistp256@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,ssh-ed25519,sk-ssh-ed25519@openssh.com,rsa-sha2-256,rsa-sha2-512
07070100000087000081A4000003E800000064000000016005CA76000000AE000000000000000000000000000000000000004900000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FUTURE-openssl.txt@SECLEVEL=3:kEECDH:kEDH:kPSK:kDHEPSK:kECDHEPSK:-kRSAPSK:-kRSA:-aDSS:-AES128:-SHA256:-3DES:!DES:!RC4:!RC2:!IDEA:-SEED:!eNULL:!aNULL:-SHA1:!MD5:-SHA384:-CAMELLIA:-ARIA:-AESCCM807070100000088000081A4000003E800000064000000016005CA760000020D000000000000000000000000000000000000004C00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/FUTURE-opensslcnf.txtCipherString = @SECLEVEL=3:kEECDH:kEDH:kPSK:kDHEPSK:kECDHEPSK:-kRSAPSK:-kRSA:-aDSS:-AES128:-SHA256:-3DES:!DES:!RC4:!RC2:!IDEA:-SEED:!eNULL:!aNULL:-SHA1:!MD5:-SHA384:-CAMELLIA:-ARIA:-AESCCM8
Ciphersuites = TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256
MinProtocol = TLSv1.2
MaxProtocol = TLSv1.3
SignatureAlgorithms = ECDSA+SHA256:ECDSA+SHA384:ECDSA+SHA512:ed25519:ed448:rsa_pss_pss_sha256:rsa_pss_pss_sha384:rsa_pss_pss_sha512:rsa_pss_rsae_sha256:rsa_pss_rsae_sha384:rsa_pss_rsae_sha512:RSA+SHA256:RSA+SHA384:RSA+SHA51207070100000089000081A4000003E800000064000000016005CA7600000075000000000000000000000000000000000000004900000000fedora-crypto-policies-20210118.b21c811/tests/outputs/GOST-ONLY-bind.txtdisable-algorithms "." {
RSAMD5;
RSASHA1;
NSEC3RSASHA1;
DSA;
};
disable-ds-digests "." {
SHA-256;
SHA-384;
SHA-1;
};
0707010000008A000081A4000003E800000064000000016005CA7600000998000000000000000000000000000000000000004B00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/GOST-ONLY-gnutls.txt[overrides]
insecure-hash = SHA256
insecure-hash = SHA384
insecure-hash = SHA512
insecure-hash = SHA3-256
insecure-hash = SHA3-384
insecure-hash = SHA3-512
insecure-hash = SHA1
insecure-hash = MD5
tls-disabled-mac = SHA1
tls-disabled-mac = SHA256
tls-disabled-mac = SHA384
tls-disabled-mac = SHA512
tls-disabled-mac = MD5
tls-disabled-group = GROUP-X25519
tls-disabled-group = GROUP-SECP256R1
tls-disabled-group = GROUP-SECP384R1
tls-disabled-group = GROUP-SECP521R1
tls-disabled-group = GROUP-X448
tls-disabled-group = GROUP-FFDHE2048
tls-disabled-group = GROUP-FFDHE3072
tls-disabled-group = GROUP-FFDHE4096
tls-disabled-group = GROUP-FFDHE6144
tls-disabled-group = GROUP-FFDHE8192
insecure-sig = RSA-MD5
insecure-sig = RSA-SHA1
insecure-sig = DSA-SHA1
insecure-sig = ECDSA-SHA1
insecure-sig = RSA-SHA224
insecure-sig = DSA-SHA224
insecure-sig = ECDSA-SHA224
insecure-sig = RSA-SHA256
insecure-sig = DSA-SHA256
insecure-sig = ECDSA-SHA256
insecure-sig = RSA-SHA384
insecure-sig = DSA-SHA384
insecure-sig = ECDSA-SHA384
insecure-sig = RSA-SHA512
insecure-sig = DSA-SHA512
insecure-sig = ECDSA-SHA512
insecure-sig = EDDSA-ED25519
insecure-sig = EDDSA-ED448
insecure-sig = RSA-PSS-SHA256
insecure-sig = RSA-PSS-SHA384
insecure-sig = RSA-PSS-SHA512
insecure-sig = RSA-PSS-RSAE-SHA256
insecure-sig = RSA-PSS-RSAE-SHA384
insecure-sig = RSA-PSS-RSAE-SHA512
insecure-sig-for-cert = rsa-sha1
insecure-sig-for-cert = dsa-sha1
insecure-sig-for-cert = ecdsa-sha1
tls-disabled-cipher = AES-256-GCM
tls-disabled-cipher = AES-256-CCM
tls-disabled-cipher = AES-128-GCM
tls-disabled-cipher = AES-128-CCM
tls-disabled-cipher = CHACHA20-POLY1305
tls-disabled-cipher = CAMELLIA-256-GCM
tls-disabled-cipher = CAMELLIA-128-GCM
tls-disabled-cipher = AES-256-CBC
tls-disabled-cipher = AES-128-CBC
tls-disabled-cipher = CAMELLIA-256-CBC
tls-disabled-cipher = CAMELLIA-128-CBC
tls-disabled-cipher = 3DES-CBC
tls-disabled-cipher = ARCFOUR-128
tls-disabled-cipher = GOST28147-TC26Z-CFB
tls-disabled-cipher = GOST28147-CPB-CFB
tls-disabled-cipher = GOST28147-CPC-CFB
tls-disabled-cipher = GOST28147-CPD-CFB
tls-disabled-kx = PSK
tls-disabled-kx = DHE-PSK
tls-disabled-kx = ECDHE-PSK
tls-disabled-kx = RSA-PSK
tls-disabled-kx = ECDHE-RSA
tls-disabled-kx = ECDHE-ECDSA
tls-disabled-kx = RSA
tls-disabled-kx = DHE-RSA
tls-disabled-kx = DHE-DSS
disabled-version = SSL3.0
disabled-version = DTLS1.0
disabled-version = DTLS1.2
min-verification-profile = medium

[priorities]
SYSTEM=NORMAL
0707010000008B000081A4000003E800000064000000016005CA760000030D000000000000000000000000000000000000004900000000fedora-crypto-policies-20210118.b21c811/tests/outputs/GOST-ONLY-java.txtjdk.tls.ephemeralDHKeySize=2048
jdk.certpath.disabledAlgorithms=MD2, SHA256, SHA384, SHA512, SHA3_256, SHA3_384, SHA3_512, SHA224, SHA1, MD5, DSA, RSA keySize < 2048
jdk.tls.disabledAlgorithms=DH keySize < 2048, SSLv2, SSLv3, RSAPSK, ECDHE, TLS_RSA_WITH_AES_256_CBC_SHA256, TLS_RSA_WITH_AES_256_CBC_SHA, TLS_RSA_WITH_AES_128_CBC_SHA256, TLS_RSA_WITH_AES_128_CBC_SHA, TLS_RSA_WITH_AES_256_GCM_SHA384, TLS_RSA_WITH_AES_128_GCM_SHA256, DHE_RSA, DHE_DSS, RSA_EXPORT, DHE_DSS_EXPORT, DHE_RSA_EXPORT, DH_DSS_EXPORT, DH_RSA_EXPORT, DH_anon, ECDH_anon, DH_RSA, DH_DSS, ECDH, AES_256_GCM, AES_256_CCM, AES_128_GCM, AES_128_CCM, AES_256_CBC, AES_128_CBC, 3DES_EDE_CBC, DES_CBC, RC4_40, RC4_128, DES40_CBC, RC2, HmacSHA1, HmacSHA256, HmacSHA384, HmacSHA512, HmacMD5
jdk.tls.legacyAlgorithms=
0707010000008C000081A4000003E800000064000000016005CA7600000024000000000000000000000000000000000000004900000000fedora-crypto-policies-20210118.b21c811/tests/outputs/GOST-ONLY-krb5.txt[libdefaults]
permitted_enctypes = 
0707010000008D000081A4000003E800000064000000016005CA7600000017000000000000000000000000000000000000004E00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/GOST-ONLY-libreswan.txtconn %default
	pfs=yes
0707010000008E000081A4000003E800000064000000016005CA7600000000000000000000000000000000000000000000004B00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/GOST-ONLY-libssh.txt0707010000008F000081A4000003E800000064000000016005CA76000000A1000000000000000000000000000000000000004800000000fedora-crypto-policies-20210118.b21c811/tests/outputs/GOST-ONLY-nss.txtlibrary=
name=Policy
NSS=flags=policyOnly,moduleDB
config="disallow=ALL allow=tls-version-min=tls1.0:dtls-version-min=0:DH-MIN=2048:DSA-MIN=2048:RSA-MIN=2048"

07070100000090000081A4000003E800000064000000016005CA7600000015000000000000000000000000000000000000004C00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/GOST-ONLY-openssh.txtGSSAPIKeyExchange no
07070100000091000081A4000003E800000064000000016005CA7600000015000000000000000000000000000000000000005200000000fedora-crypto-policies-20210118.b21c811/tests/outputs/GOST-ONLY-opensshserver.txtGSSAPIKeyExchange no
07070100000092000081A4000003E800000064000000016005CA76000000DC000000000000000000000000000000000000004C00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/GOST-ONLY-openssl.txt@SECLEVEL=2:kGOST:-kPSK:-kDHEPSK:-kECDHEPSK:-kRSAPSK:-kEECDH:-kRSA:-aRSA:-aDSS:-AES256:-AES128:-CHACHA20-POLY1305:-SHA256:-3DES:!DES:!RC4:!RC2:!IDEA:-SEED:!eNULL:!aNULL:-AESCCM:-SHA1:!MD5:-SHA384:-CAMELLIA:-ARIA:-AESCCM807070100000093000081A4000003E800000064000000016005CA7600000156000000000000000000000000000000000000004F00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/GOST-ONLY-opensslcnf.txtCipherString = @SECLEVEL=2:kGOST:-kPSK:-kDHEPSK:-kECDHEPSK:-kRSAPSK:-kEECDH:-kRSA:-aRSA:-aDSS:-AES256:-AES128:-CHACHA20-POLY1305:-SHA256:-3DES:!DES:!RC4:!RC2:!IDEA:-SEED:!eNULL:!aNULL:-AESCCM:-SHA1:!MD5:-SHA384:-CAMELLIA:-ARIA:-AESCCM8
Ciphersuites = GOST2012-GOST8912-GOST8912
MinProtocol = TLSv1
MaxProtocol = TLSv1.3
SignatureAlgorithms = 07070100000094000081A4000003E800000064000000016005CA7600000046000000000000000000000000000000000000004600000000fedora-crypto-policies-20210118.b21c811/tests/outputs/LEGACY-bind.txtdisable-algorithms "." {
RSAMD5;
};
disable-ds-digests "." {
GOST;
};
07070100000095000081A4000003E800000064000000016005CA760000041F000000000000000000000000000000000000004800000000fedora-crypto-policies-20210118.b21c811/tests/outputs/LEGACY-gnutls.txt[overrides]
insecure-hash = MD5
insecure-hash = STREEBOG-256
insecure-hash = STREEBOG-512
insecure-hash = GOSTR341194
tls-disabled-mac = MD5
tls-disabled-mac = STREEBOG-256
tls-disabled-mac = STREEBOG-512
tls-disabled-mac = GOST28147-TC26Z-IMIT
tls-disabled-group = GROUP-GC256B
tls-disabled-group = GROUP-GC512A
insecure-sig = RSA-MD5
insecure-sig = GOSTR341012-512
insecure-sig = GOSTR341012-256
insecure-sig = GOSTR341001
tls-disabled-cipher = CAMELLIA-256-GCM
tls-disabled-cipher = CAMELLIA-128-GCM
tls-disabled-cipher = CAMELLIA-256-CBC
tls-disabled-cipher = CAMELLIA-128-CBC
tls-disabled-cipher = GOST28147-TC26Z-CFB
tls-disabled-cipher = GOST28147-CPA-CFB
tls-disabled-cipher = GOST28147-CPB-CFB
tls-disabled-cipher = GOST28147-CPC-CFB
tls-disabled-cipher = GOST28147-CPD-CFB
tls-disabled-cipher = GOST28147-TC26Z-CNT
tls-disabled-kx = VKO-GOST-12
disabled-version = SSL3.0
min-verification-profile = low

[priorities]
SYSTEM=NORMAL:+SIGN-DSA-SHA256:+SIGN-DSA-SHA384:+SIGN-DSA-SHA512:+SIGN-DSA-SHA224:+SIGN-DSA-SHA1:+3DES-CBC:+ARCFOUR-128:+DHE-DSS
07070100000096000081A4000003E800000064000000016005CA7600000165000000000000000000000000000000000000004600000000fedora-crypto-policies-20210118.b21c811/tests/outputs/LEGACY-java.txtjdk.tls.ephemeralDHKeySize=1023
jdk.certpath.disabledAlgorithms=MD2, MD5, RSA keySize < 1023
jdk.tls.disabledAlgorithms=DH keySize < 1023, SSLv2, SSLv3, RSA_EXPORT, DHE_DSS_EXPORT, DHE_RSA_EXPORT, DH_DSS_EXPORT, DH_RSA_EXPORT, DH_anon, ECDH_anon, DH_RSA, DH_DSS, ECDH, DES_CBC, RC4_40, DES40_CBC, RC2, HmacMD5
jdk.tls.legacyAlgorithms=3DES_EDE_CBC, RC4_128
07070100000097000081A4000003E800000064000000016005CA76000000B3000000000000000000000000000000000000004600000000fedora-crypto-policies-20210118.b21c811/tests/outputs/LEGACY-krb5.txt[libdefaults]
permitted_enctypes = aes256-cts-hmac-sha1-96 aes256-cts-hmac-sha384-192 camellia256-cts-cmac aes128-cts-hmac-sha256-128 aes128-cts-hmac-sha1-96 camellia128-cts-cmac
07070100000098000081A4000003E800000064000000016005CA7600000252000000000000000000000000000000000000004B00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/LEGACY-libreswan.txtconn %default
	ikev2=insist
	pfs=yes
	ike=aes_gcm256-sha2_512+sha2_256-dh19+dh14+dh31+dh20+dh21+dh15+dh16+dh18+dh5,chacha20_poly1305-sha2_512+sha2_256-dh19+dh14+dh31+dh20+dh21+dh15+dh16+dh18+dh5,aes256-sha2_512+sha2_256-dh19+dh14+dh31+dh20+dh21+dh15+dh16+dh18+dh5,aes_gcm128-sha2_512+sha2_256-dh19+dh14+dh31+dh20+dh21+dh15+dh16+dh18+dh5,aes128-sha2_256-dh19+dh14+dh31+dh20+dh21+dh15+dh16+dh18+dh5
	esp=aes_gcm256,chacha20_poly1305,aes256-sha2_512+sha1+sha2_256,aes_gcm128,aes128-sha1+sha2_256
	authby=ecdsa-sha2_256,ecdsa-sha2_384,ecdsa-sha2_512,rsa-sha2_256,rsa-sha2_384,rsa-sha2_512,rsa-sha1
07070100000099000081A4000003E800000064000000016005CA760000059A000000000000000000000000000000000000004800000000fedora-crypto-policies-20210118.b21c811/tests/outputs/LEGACY-libssh.txtCiphers aes256-gcm@openssh.com,chacha20-poly1305@openssh.com,aes256-ctr,aes256-cbc,aes128-gcm@openssh.com,aes128-ctr,aes128-cbc,3des-cbc
MACs hmac-sha2-256-etm@openssh.com,hmac-sha1-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-sha2-256,hmac-sha1,hmac-sha2-512
KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org,ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group14-sha256,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512,diffie-hellman-group-exchange-sha1,diffie-hellman-group14-sha1,diffie-hellman-group1-sha1
HostKeyAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com,ssh-rsa,ssh-rsa-cert-v01@openssh.com,ssh-dss,ssh-dss-cert-v01@openssh.com
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com,ssh-rsa,ssh-rsa-cert-v01@openssh.com,ssh-dss,ssh-dss-cert-v01@openssh.com
0707010000009A000081A4000003E800000064000000016005CA76000001B3000000000000000000000000000000000000004500000000fedora-crypto-policies-20210118.b21c811/tests/outputs/LEGACY-nss.txtlibrary=
name=Policy
NSS=flags=policyOnly,moduleDB
config="disallow=ALL allow=HMAC-SHA256:HMAC-SHA1:HMAC-SHA384:HMAC-SHA512:CURVE25519:SECP256R1:SECP384R1:SECP521R1:aes256-gcm:chacha20-poly1305:aes256-cbc:aes128-gcm:aes128-cbc:des-ede3-cbc:rc4:SHA256:SHA384:SHA512:SHA224:SHA1:ECDHE-RSA:ECDHE-ECDSA:RSA:DHE-RSA:DHE-DSS:ECDSA:RSA-PSS:RSA-PKCS:DSA:tls-version-min=tls1.0:dtls-version-min=dtls1.0:DH-MIN=1023:DSA-MIN=1023:RSA-MIN=1023"

0707010000009B000081A4000003E800000064000000016005CA7600000617000000000000000000000000000000000000004900000000fedora-crypto-policies-20210118.b21c811/tests/outputs/LEGACY-openssh.txtCiphers aes256-gcm@openssh.com,chacha20-poly1305@openssh.com,aes256-ctr,aes256-cbc,aes128-gcm@openssh.com,aes128-ctr,aes128-cbc,3des-cbc
MACs hmac-sha2-256-etm@openssh.com,hmac-sha1-etm@openssh.com,umac-128-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-sha2-256,hmac-sha1,umac-128@openssh.com,hmac-sha2-512
GSSAPIKexAlgorithms gss-curve25519-sha256-,gss-nistp256-sha256-,gss-group14-sha256-,gss-group16-sha512-,gss-gex-sha1-,gss-group14-sha1-,gss-group1-sha1-
KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org,ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group14-sha256,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512,diffie-hellman-group-exchange-sha1,diffie-hellman-group14-sha1,diffie-hellman-group1-sha1
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,sk-ecdsa-sha2-nistp256@openssh.com,sk-ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,sk-ssh-ed25519@openssh.com,sk-ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com,ssh-rsa,ssh-rsa-cert-v01@openssh.com,ssh-dss,ssh-dss-cert-v01@openssh.com
CASignatureAlgorithms ecdsa-sha2-nistp256,sk-ecdsa-sha2-nistp256@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,ssh-ed25519,sk-ssh-ed25519@openssh.com,rsa-sha2-256,rsa-sha2-512,ssh-rsa,ssh-dss
0707010000009C000081A4000003E800000064000000016005CA7600000817000000000000000000000000000000000000004F00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/LEGACY-opensshserver.txtCiphers aes256-gcm@openssh.com,chacha20-poly1305@openssh.com,aes256-ctr,aes256-cbc,aes128-gcm@openssh.com,aes128-ctr,aes128-cbc,3des-cbc
MACs hmac-sha2-256-etm@openssh.com,hmac-sha1-etm@openssh.com,umac-128-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-sha2-256,hmac-sha1,umac-128@openssh.com,hmac-sha2-512
GSSAPIKexAlgorithms gss-curve25519-sha256-,gss-nistp256-sha256-,gss-group14-sha256-,gss-group16-sha512-,gss-gex-sha1-,gss-group14-sha1-
KexAlgorithms curve25519-sha256,curve25519-sha256@libssh.org,ecdh-sha2-nistp256,ecdh-sha2-nistp384,ecdh-sha2-nistp521,diffie-hellman-group-exchange-sha256,diffie-hellman-group14-sha256,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512,diffie-hellman-group-exchange-sha1,diffie-hellman-group14-sha1
HostKeyAlgorithms ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,sk-ecdsa-sha2-nistp256@openssh.com,sk-ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,sk-ssh-ed25519@openssh.com,sk-ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com,ssh-rsa,ssh-rsa-cert-v01@openssh.com,ssh-dss,ssh-dss-cert-v01@openssh.com
PubkeyAcceptedKeyTypes ecdsa-sha2-nistp256,ecdsa-sha2-nistp256-cert-v01@openssh.com,sk-ecdsa-sha2-nistp256@openssh.com,sk-ecdsa-sha2-nistp256-cert-v01@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp384-cert-v01@openssh.com,ecdsa-sha2-nistp521,ecdsa-sha2-nistp521-cert-v01@openssh.com,ssh-ed25519,ssh-ed25519-cert-v01@openssh.com,sk-ssh-ed25519@openssh.com,sk-ssh-ed25519-cert-v01@openssh.com,rsa-sha2-256,rsa-sha2-256-cert-v01@openssh.com,rsa-sha2-512,rsa-sha2-512-cert-v01@openssh.com,ssh-rsa,ssh-rsa-cert-v01@openssh.com,ssh-dss,ssh-dss-cert-v01@openssh.com
CASignatureAlgorithms ecdsa-sha2-nistp256,sk-ecdsa-sha2-nistp256@openssh.com,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,ssh-ed25519,sk-ssh-ed25519@openssh.com,rsa-sha2-256,rsa-sha2-512,ssh-rsa,ssh-dss
0707010000009D000081A4000003E800000064000000016005CA7600000085000000000000000000000000000000000000004900000000fedora-crypto-policies-20210118.b21c811/tests/outputs/LEGACY-openssl.txt@SECLEVEL=1:kEECDH:kRSA:kEDH:kPSK:kDHEPSK:kECDHEPSK:kRSAPSK:!DES:!RC2:!IDEA:-SEED:!eNULL:!aNULL:!MD5:-SHA384:-CAMELLIA:-ARIA:-AESCCM80707010000009E000081A4000003E800000064000000016005CA7600000271000000000000000000000000000000000000004C00000000fedora-crypto-policies-20210118.b21c811/tests/outputs/LEGACY-opensslcnf.txtCipherString = @SECLEVEL=1:kEECDH:kRSA:kEDH:kPSK:kDHEPSK:kECDHEPSK:kRSAPSK:!DES:!RC2:!IDEA:-SEED:!eNULL:!aNULL:!MD5:-SHA384:-CAMELLIA:-ARIA:-AESCCM8
Ciphersuites = TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256:TLS_AES_128_CCM_SHA256
MinProtocol = TLSv1
MaxProtocol = TLSv1.3
SignatureAlgorithms = ECDSA+SHA256:ECDSA+SHA384:ECDSA+SHA512:ed25519:ed448:rsa_pss_pss_sha256:rsa_pss_pss_sha384:rsa_pss_pss_sha512:rsa_pss_rsae_sha256:rsa_pss_rsae_sha384:rsa_pss_rsae_sha512:RSA+SHA256:RSA+SHA384:RSA+SHA512:ECDSA+SHA224:RSA+SHA224:DSA+SHA256:DSA+SHA384:DSA+SHA512:DSA+SHA224:ECDSA+SHA1:RSA+SHA1:DSA+SHA10707010000009F000081ED000003E800000064000000016005CA760000053A000000000000000000000000000000000000004100000000fedora-crypto-policies-20210118.b21c811/tests/test-fips-setup.sh#!/bin/sh

current_policy="$(update-crypto-policies --show)"

if [ -z "$current_policy" ]; then
	exit 1
fi

action1=--enable
action2=--disable

check_fips_enabled () {
	if ! fips-mode-setup --is-enabled;then
		echo "FIPS --is-enabled did not detect FIPS mode!"
		# do not bother checking in containers that are not
		# running in FIPS enabled kernels.
		if test -e /proc/sys/crypto/fips_enabled;then
			exit 1
		fi
	fi
}

check_fips_disabled () {
	if fips-mode-setup --is-enabled;then
		echo "FIPS --is-enabled detected FIPS mode when it shouldn't!"
		exit 1
	fi
}

if fips-mode-setup --is-enabled; then
	action1=--disable
	action2=--enable
fi

fips-mode-setup --no-bootcfg $action1 || exit $?

if [ $action1 = --enable ] ; then
	[ -f /etc/system-fips ] || exit 2
	[ ! -d /etc/dracut.conf.d ] || [ -f /etc/dracut.conf.d/40-fips.conf ] || exit 3
	grep -q FIPS ${CONFDIR}/config || exit $?

check_fips_enabled
else
	check_fips_disabled
fi

fips-mode-setup --no-bootcfg $action2 || exit $?

if [ $action2 = --enable ]; then
	[ -f /etc/system-fips ] || exit 2
	[ ! -d /etc/dracut.conf.d ] || [ -f /etc/dracut.conf.d/40-fips.conf ] || exit 3
	grep -q FIPS ${CONFDIR}/config || exit $?

check_fips_enabled
else
	check_fips_disabled
fi

if [ $current_policy != FIPS ] ; then
	update-crypto-policies --set $current_policy || exit $?
fi

exit 0
070701000000A0000081ED000003E800000064000000016005CA7600000F4E000000000000000000000000000000000000004800000000fedora-crypto-policies-20210118.b21c811/tests/update-crypto-policies.sh#!/bin/sh

set -e

umask 022

: ${top_srcdir=..}

progname="$0"
script="$top_srcdir/python/update-crypto-policies.py"
testdir=`mktemp -d -t "update-crypto-policies.XXXXXXXX"`
trap 'rm -rf $testdir' 0

profile_dir="$testdir/profile"
mkdir "$profile_dir"

base_dir="$testdir/base"
mkdir "$base_dir"
mkdir "$base_dir/local.d"

(cd "$top_srcdir" ; python/build-crypto-policies.py --reloadcmds policies "$profile_dir" 2>/dev/null)
cp -pr "$top_srcdir/policies" "$profile_dir"
echo DEFAULT > "$profile_dir/default-config"
echo DEFAULT > "$base_dir/config"

check_symlink() {
	for profile_file in "$profile_dir"/"$1"/*.txt; do
		profile_base=$(basename "$profile_file")
		config_file="$base_dir/back-ends/${profile_base%%.txt}.config"
		test -h "$config_file" || {
			echo "$progname: $config_file is not a symlink"
			exit 1
		}
		target_file=$(readlink "$config_file")
		test "$target_file" = "$profile_file" || {
			echo "$progname: $target_file is not a symlink to $profile_file"
			exit 1
		}
	done
}

echo "$0: checking if default profile is properly selected"
profile_dir="$profile_dir" base_dir="$base_dir" "$script" --no-reload
check_symlink DEFAULT
echo

check_compare() {
	for profile_file in "$profile_dir"/"$1"/*.txt; do
		profile_base=$(basename "$profile_file")
		config_file="$base_dir/back-ends/${profile_base%%.txt}.config"
		test ! -h "$config_file" || {
			echo "$progname: $config_file is a symlink"
			exit 1
		}
		cmp "$config_file" "$profile_file" || exit 1
	done
}

echo "$0: checking if current policy dump is equal to the original default profile"
mkdir -p "$base_dir/policies"
grep -q "^# DEFAULT\$" "$base_dir/state/CURRENT.pol" || {
	echo "$progname: CURRENT.pol does not contain correct policy name"
	exit 1
}
cp "$base_dir/state/CURRENT.pol" "$base_dir/policies"
profile_dir="$profile_dir" base_dir="$base_dir" "$script" --no-reload --set CURRENT
check_compare DEFAULT
echo

echo "$0: checking if switching to other profile works"
profile_dir="$profile_dir" base_dir="$base_dir" "$script" --no-reload --set LEGACY
check_symlink LEGACY

check_local() {
	profile_file="$profile_dir"/"$1"/"$2".txt
	config_file="$base_dir/back-ends/$2.config"
	test -f "$config_file" || {
		echo "$progname: $config_file is not a regular file"
		exit 1
	}
	cat "$profile_file" "$base_dir/local.d"/"$2"-*.config > "$testdir/merged"
	diff -u "$config_file" "$testdir/merged" || {
		echo "$progname: $config_file is not properly merged"
		exit 1
	}
}
echo

echo "$0: checking if local.d works"

cat > "$base_dir/local.d/nss-foo.config" <<EOF
name=foo
library=foo.so
EOF

cat > "$base_dir/local.d/nss-bar.config" <<EOF
name=bar
library=bar.so
EOF

profile_dir="$profile_dir" base_dir="$base_dir" "$script" --no-reload --set DEFAULT
check_local DEFAULT nss

echo

echo "$0: checking if --check works (test 1)"
profile_dir="$profile_dir" base_dir="$base_dir" "$script" --no-reload --check

cat >> "$base_dir/back-ends/nss.config" <<EOF
# a change
EOF

if profile_dir="$profile_dir" base_dir="$base_dir" "$script" --no-reload --check ; then
	echo "--check didn't detect a modification"
	exit 1
else
	echo "--check works as expected"
fi

echo

echo "$0: checking if --check works (test 2)"
# regenerate "$base_dir/back-ends/nss.config"
profile_dir="$profile_dir" base_dir="$base_dir" "$script" --no-reload --set DEFAULT
# test that regen works
profile_dir="$profile_dir" base_dir="$base_dir" "$script" --no-reload --check

# convert the symlink to a regular file and then modify it
cat "$base_dir/back-ends/bind.config" > "$base_dir/back-ends/bind.config.new"
rm -f "$base_dir/back-ends/bind.config"
mv "$base_dir/back-ends/bind.config.new" "$base_dir/back-ends/bind.config"
cat >> "$base_dir/back-ends/bind.config" <<EOF
# a change
EOF

if profile_dir="$profile_dir" base_dir="$base_dir" "$script" --no-reload --check ; then
	echo "--check didn't detect a modification"
	exit 1
else
	echo "--check works as expected"
fi
070701000000A1000081ED000003E800000064000000016005CA7600000479000000000000000000000000000000000000003F00000000fedora-crypto-policies-20210118.b21c811/tests/verify-output.pl#!/usr/bin/perl

use strict;
use warnings;

my $libdir = "./back-ends/";
use lib "back-ends/";

use profiles::common;

my @modules = ("gnutls", "openssl", "opensslcnf", "bind", "java", "krb5", "nss",
	       "openssh", "opensshserver", "libreswan", "libssh");
my ($mod, $contents, $profile);
my @reloadcmds = ();

print "Verifying the contents of individual profile configurations\n";

foreach $mod (@modules) {
	require "$libdir/$mod.pl";
	my $tmp = '';

mkdir("tests/outputs");
	foreach $profile (@profiles::common::policies) {
		$tmp = generate_temp_policy($profile, 0, $libdir, \@reloadcmds);
		$contents = '';

if (open my $fh, '<', "tests/outputs/$profile-$mod.txt") {
			$/ = undef;
			$contents = <$fh>;
			close $fh;
			$/ = "\n";

if ($tmp ne $contents) {
				print "\nError in the contents of $profile-$mod.txt\n";
				print "If the changes in the output policies are expected run make 'reset-outputs' and verify the result\n";
				exit 1;
			}
		} else {
			open my $fh, '>', "tests/outputs/$profile-$mod.txt";
			print $fh $tmp;
			close $fh;
		}

test_temp_policy($profile, 0, $tmp) if ($profile ne 'EMPTY');
	}
}

exit 0;
070701000000A2000081ED000003E800000064000000016005CA7600000057000000000000000000000000000000000000003F00000000fedora-crypto-policies-20210118.b21c811/update-crypto-policies#!/usr/bin/sh

exec "/usr/share/crypto-policies/python/update-crypto-policies.py" "$@"
070701000000A3000081A4000003E800000064000000016005CA7600002BC7000000000000000000000000000000000000004500000000fedora-crypto-policies-20210118.b21c811/update-crypto-policies.8.txt////
Copyright (C) 2014-2018 Red Hat, Inc.

update-crypto-policies(8)
=========================
:doctype: manpage
:man source: update-crypto-policies

NAME
----
update-crypto-policies - manage the policies available to the various
cryptographic back-ends.

SYNOPSIS
--------
*update-crypto-policies* ['COMMAND']

DESCRIPTION
-----------
*update-crypto-policies(8)* is used to set the policy applicable for the
various cryptographic back-ends, such as SSL/TLS libraries. That will
be the default policy used by these back-ends unless the application user
configures them otherwise.

The available policies are described in the *crypto-policies(7)* manual
page.

The desired system policy is selected in /etc/crypto-policies/config
and this tool will generate the individual policy requirements for
all back-ends that support such configuration. After this tool is called
the administrator is assured that any application that utilizes the
supported back-ends will follow a policy that adheres to the configured profile.

Note that the above assurance does apply to the extent that applications
are configured to follow the default policy (the details vary on the back-end, see below
for more information).

The generated back-end policies will be placed in /etc/crypto-policies/back-ends.
Currently the supported back-ends are:

* GnuTLS library

* OpenSSL library

* NSS library

* OpenJDK

* Libkrb5

* BIND

* OpenSSH

* Libreswan

* libssh

Applications and languages which rely on any of these back-ends will follow
the system policies as well. Examples are apache httpd, nginx, php, and
others.

In general after changing the system crypto policies with the
`update-crypto-policies --set` command it is recommended to restart the
system for the effect to fully take place as the policy configuration
files are loaded on application start-up. Otherwise applications started
before the command was run need to be restarted to load the updated
configuration.

[[options]]
COMMANDS
-------

The following commands are available in update-crypto-policies tool.

* --set:        Sets the current policy and overwrites the config file.

* --show:       Shows the currently applied crypto policy.

* --is-applied: Returns success if the currently configured policy in
                the config file was applied by running the
                update-crypto-policies.

* --check:      Returns success if freshly generated configuration files match
                the current policy. The check will return failure if there
                is a manual modification of the back-end configuration files
                or a newer version of crypto-policies package is installed without
                running update-crypto-policies. This should not happen with
                system updates because update-crypto-policies is run implicitly
                there.

OPTIONS
-------

The following options are available in update-crypto-policies tool.

* --no-reload:  By default this tool causes some running applications to reload the
                configured policy. This option skips the reloading.

[[appsupport]]
APPLICATION SUPPORT
-------------------
Applications in the operating system that provide a default configuration file
that includes a cryptographic policy string will be modified gradually to
support these policies.

When an application provides a configuration file, the changes needed to
utilize the system-wide policy are the following.

* Applications using OpenSSL: If an application allows the configuration of
  ciphersuite string, the special cipher string "PROFILE=SYSTEM" should replace any other cipher string.
  Applications which use the default library settings automatically adhere to the policy.
  Applications following the policy inherit the settings for cipher suite preference.
  By default the OpenSSL library reads a configuration file when it is initialized. If
  the application does not override loading of the configuration file, the policy also
  sets the minimum TLS protocol version and default cipher suite preference via this
  file. If the application is long-running such as the httpd server it has to be restarted
  to reload the configuration file after policy is changed. Otherwise the changed policy
  cannot take effect.

* Applications using GnuTLS: Applications using GnuTLS will load the crypto policies
  by default. To prevent applications from adhering to the policy the GNUTLS_SYSTEM_PRIORITY_FILE
  environment variable must be set on an empty file (e.g., /dev/null).
  The policy covers the settings for cipher suite preference, TLS and DTLS
  protocol versions, allowed elliptic curves, and limits for cryptographic keys.

* Applications using NSS: Applications using NSS will load the crypto policies by
  default. They inherit the settings for cipher suite preference, TLS
  and DTLS protocol versions, allowed elliptic curves, and limits for
  cryptographic keys. To prevent applications from adhering
  to the policy the NSS_IGNORE_SYSTEM_POLICY environment variable must be set to 1
  prior to executing that application.

* Applications using Java: No special treatment is required. Applications using
  Java will load the crypto policies by default.
  These applications will then inherit the settings for allowed cipher suites,
  allowed TLS and DTLS protocol versions, allowed elliptic curves, and limits for
  cryptographic keys. To prevent openjdk applications from adhering
  to the policy the `<java.home>/jre/lib/security/java.security` file should
  be edited to contain `security.useSystemPropertiesFile=false` or the system
  property `java.security.disableSystemPropertiesFile` be set to `true`.
  Note that the system property `java.security.properties` is loaded with
  a lower preference than the crypto policies, so you can't use this property
  to override crypto policies without also preventing openjdk applications
  from adhering to the policy.

* Applications using libkrb5: No special treatment is required. Applications
  will follow the crypto policies by default. These applications inherit the
  settings for the permitted encryption types for tickets as well as the
  cryptographic key limits for the PKINIT protocol. A system-wide opt-out is
  available by deleting the /etc/krb5.conf.d/crypto-policies link.

* BIND: This application inherits the set of blacklisted algorithms. To
   opt-out from the policy, remove the policy include directive in the
   named.conf file.

* OpenSSH: Both server and client application inherits the cipher preferences,
   the key exchange algorithms as well as the GSSAPI key exchange algorithms.
   To opt-out from the policy for client, override the global ssh_config with a
   user-specific configuration in ~/.ssh/config. See ssh_config(5) for more
   information.
   To override some configuration option in server, use a drop-in directory
   /etc/ssh/sshd_config.d/ to create a file lexicographically preceding
   05-redhat.conf which is currently including crypto policies configuration
   file.

* Libreswan: Both servers and clients inherit the ESP and IKE preferences,
   if they are not overridden in the connection configuration file. Note that
   due to limitations of libreswan, crypto policies is restricted to supporting IKEv2.
   To opt-out from the policy, comment the line including `/etc/crypto-policies/back-ends/libreswan.config`
   from `/etc/ipsec.conf`.

* Applications using libssh: Both client and server applications using libssh
   will load the crypto policies by default. They inherit the ciphers, key
   exchange, message authentication, and signature algorithms preferences.

[[policyconfig]]
POLICY CONFIGURATION
--------------------
One of the supported profiles should be set in /etc/crypto-policies/config
and this script should be run afterwards.

In case of a parsing error no policies will be updated.

CUSTOM POLICIES
---------------
The custom policies can take two forms. First form is a full custom policy file
which is supported by the update-crypto-policies tool in the same way as the
policies shipped along the tool in the package.

The second form can be called a subpolicy or policy modifier. This form modifies
aspects of any base policy file by removing or adding algorithms or protocols.
The subpolicies can be appended on the update-crypto-policies --set command
line to the base policy separated by the `:` character. There can be multiple
subpolicies appended.

Let's suppose we have subpolicy NO-SHA1 that drops support for SHA1 hash
and subpolicy GOST that enables support for the various algorithms specified
in Russian GOST standards. You can set the DEFAULT policy with disabled SHA1
support and enabled GOST support by running the following command:

`update-crypto-policies --set DEFAULT:NO-SHA1:GOST`

This command generates and applies configuration that will be modification of
the DEFAULT policy with changes specified in the NO-SHA1 and GOST subpolicies.

FILES
-----
/etc/crypto-policies/config::
	The file contains the system policy to be applied when
	`update-crypto-policies` is run without any arguments. It should
	contain a string of one of the profiles listed in the
	*crypto-policies(7)* page (e.g., DEFAULT) or any custom policy
	name with subpolicies separated by the `:` character. The
	file is overwritten when `update-crypto-policies --set` is executed.

/etc/crypto-policies/back-ends::
	Contains the generated policies in separated files, and in a format readable
	by the supported back ends.

/etc/crypto-policies/local.d::
	Contains additional files to be appended to the generated policy
	files. The files present must adhere to $app-XXX.config file naming, where
	XXX is any arbitrary identifier. For example, to append a line to
	GnuTLS' generated policy, create a gnutls-extra-line.config file in
	local.d. This will be appended to the generated gnutls.config during
	update-crypto-policies. Please note that because the mechanism just appends
	a line to the back-end configuration the effect varies among the back-ends.
	For some of the back-ends the override fully replaces the original policy
	and for other back-ends the override might not be effective at all.

/etc/crypto-policies/state/current::
	The file contains the current system policy name with eventual subpolicies
	as of the last execution of the `update-crypto-policies` command.

/etc/crypto-policies/state/CURRENT.pol::
	The file contains the current system policy definition with all the
	modifications from eventual subpolicies applied and is written
	when the `update-crypto-policies` command is executed.

SEE ALSO
--------
crypto-policies(7), fips-mode-setup(8)

AUTHOR
------
Written by Nikos Mavrogiannopoulos.
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!506 blocks

Places

File fedora-crypto-policies-20210118.b21c811.obscpio of Package crypto-policies (Revision 96bee8568d93a6aa7c3dda2166b7cb56)

Places