Version 1.0 3 CMMC Model 2.1 Background on Maturity Models In general, a maturity model is a set of characteristics, attributes, indicators, or patterns that represent capability and progression in a particular discipline. The content of such a model typically exemplifies best practices and may incorporate standards or other codes of practice. Debian Social Contract, Version 1.0. Version 1.0 ratified on July 5, 1997. Superseded by Version 1.1, ratified on April 26, 2004. Debian, the producers of the Debian GNU/Linux system, have created the Debian Social Contract.The Debian Free Software Guidelines (DFSG) part of the contract, initially designed as a set of commitments that we agree to abide by, has been adopted by the free software.

  1. Installing Localized Versions of Dotnetfx.exe Windows 98 or Windows ME When installing the.NET Framework redistributable package, Dotnetfx.exe, on a computer running the Windows 98 or WindowsMe operating system, the system code page and font need to support the language of the dotnetfx.exe being installed.
  2. The first final version of a document will be Version 1.0. Include the date when the document becomes final. Generally, the final version is submitted to the Institutional Review Board (IRB) and/or FDA. Subsequent final documents will have an increase of “1.0” in the version number (1.0, 2.0, etc.).
  3. Examples: 1.0.0-alpha+001, 1.0.0+4700, 1.0.0-beta+exp.sha.5114f85, 1.0.0+21AF26D3—-117B344092BD. Precedence refers to how versions are compared to each other when ordered. Precedence MUST be calculated by separating the version into major, minor, patch and pre-release identifiers in that order (Build metadata does not figure into.

In the world of software management there exists a dread place called“dependency hell.” The bigger your system grows and the more packages youintegrate into your software, the more likely you are to find yourself, oneday, in this pit of despair.

In systems with many dependencies, releasing new package versions can quicklybecome a nightmare. If the dependency specifications are too tight, you are indanger of version lock (the inability to upgrade a package without having torelease new versions of every dependent package). If dependencies arespecified too loosely, you will inevitably be bitten by version promiscuity(assuming compatibility with more future versions than is reasonable).Dependency hell is where you are when version lock and/or version promiscuityprevent you from easily and safely moving your project forward.

As a solution to this problem, I propose a simple set of rules andrequirements that dictate how version numbers are assigned and incremented.For this system to work, you first need to declare a public API. This mayconsist of documentation or be enforced by the code itself. Regardless, it isimportant that this API be clear and precise. Once you identify your publicAPI, you communicate changes to it with specific increments to your versionnumber. Consider a version format of X.Y.Z (Major.Minor.Patch). Bug fixes notaffecting the API increment the patch version, backwards compatible APIadditions/changes increment the minor version, and backwards incompatible APIchanges increment the major version.

I call this system “Semantic Versioning.” Under this scheme, version numbersand the way they change convey meaning about the underlying code and what hasbeen modified from one version to the next.

Semantic Versioning Specification (SemVer)

Version 1.0 Games

The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”,“SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to beinterpreted as described in RFC 2119.

  1. Software using Semantic Versioning MUST declare a public API. This APIcould be declared in the code itself or exist strictly in documentation.However it is done, it should be precise and comprehensive.

  2. A normal version number MUST take the form X.Y.Z where X, Y, and Z areintegers. X is the major version, Y is the minor version, and Z is the patchversion. Each element MUST increase numerically by increments of one. Forinstance: 1.9.0 -> 1.10.0 -> 1.11.0.

  3. When a major version number is incremented, the minor version and patchversion MUST be reset to zero. When a minor version number is incremented, thepatch version MUST be reset to zero. For instance: 1.1.3 -> 2.0.0 and 2.1.7 ->2.2.0.

  4. A pre-release version number MAY be denoted by appending an arbitrarystring immediately following the patch version and a dash. The string MUST becomprised of only alphanumerics plus dash [0-9A-Za-z-]. Pre-release versionssatisfy but have a lower precedence than the associated normal version.Precedence SHOULD be determined by lexicographic ASCII sort order. Forinstance: 1.0.0-alpha1 < 1.0.0-beta1 < 1.0.0-beta2 < 1.0.0-rc1 < 1.0.0.

  5. Once a versioned package has been released, the contents of that versionMUST NOT be modified. Any modifications must be released as a new version.

  6. Major version zero (0.y.z) is for initial development. Anything may changeat any time. The public API should not be considered stable.

  7. Version 1.0.0 defines the public API. The way in which the version numberis incremented after this release is dependent on this public API and how itchanges.

  8. Patch version Z (x.y.Z x > 0) MUST be incremented if only backwardscompatible bug fixes are introduced. A bug fix is defined as an internalchange that fixes incorrect behavior.

  9. Minor version Y (x.Y.z x > 0) MUST be incremented if new, backwardscompatible functionality is introduced to the public API. It MAY beincremented if substantial new functionality or improvements are introducedwithin the private code. It MAY include patch level changes. Patch versionMUST be reset to 0 when minor version is incremented.

  10. Major version X (X.y.z X > 0) MUST be incremented if any backwardsincompatible changes are introduced to the public API. It MAY include minorand patch level changes. Patch and minor version MUST be reset to 0 when majorversion is incremented.

Tagging Specification (SemVerTag)

This sub-specification SHOULD be used if you use a version control system(Git, Mercurial, SVN, etc) to store your code. Using this system allowsautomated tools to inspect your package and determine SemVer compliance andreleased versions.

  1. When tagging releases in a version control system, the tag for a versionMUST be “vX.Y.Z” e.g. “v3.1.0”.

  2. The first revision that introduces SemVer compliance SHOULD be tagged“semver”. This allows pre-existing projects to assume compliance at anyarbitrary point and for automated tools to discover this fact.

Why Use Semantic Versioning?

This is not a new or revolutionary idea. In fact, you probably do somethingclose to this already. The problem is that “close” isn’t good enough. Withoutcompliance to some sort of formal specification, version numbers areessentially useless for dependency management. By giving a name and cleardefinition to the above ideas, it becomes easy to communicate your intentionsto the users of your software. Once these intentions are clear, flexible (butnot too flexible) dependency specifications can finally be made.

A simple example will demonstrate how Semantic Versioning can make dependencyhell a thing of the past. Consider a library called “Firetruck.” It requires aSemantically Versioned package named “Ladder.” At the time that Firetruck iscreated, Ladder is at version 3.1.0. Since Firetruck uses some functionalitythat was first introduced in 3.1.0, you can safely specify the Ladderdependency as greater than or equal to 3.1.0 but less than 4.0.0. Now, whenLadder version 3.1.1 and 3.2.0 become available, you can release them to yourpackage management system and know that they will be compatible with existingdependent software.

As a responsible developer you will, of course, want to verify that anypackage upgrades function as advertised. The real world is a messy place;there’s nothing we can do about that but be vigilant. What you can do is letSemantic Versioning provide you with a sane way to release and upgradepackages without having to roll new versions of dependent packages, saving youtime and hassle.

If all of this sounds desirable, all you need to do to start using SemanticVersioning is to declare that you are doing so and then follow the rules. Linkto this website from your README so others know the rules and can benefit fromthem.

FAQ

How should I deal with revisions in the 0.y.z initial development phase?

The simplest thing to do is start your initial development release at 0.1.0and then increment the minor version for each subsequent release.

How do I know when to release 1.0.0?

If your software is being used in production, it should probably already be1.0.0. If you have a stable API on which users have come to depend, you shouldbe 1.0.0. If you’re worrying a lot about backwards compatibility, you shouldprobably already be 1.0.0.

Doesn’t this discourage rapid development and fast iteration?

Major version zero is all about rapid development. If you’re changing the APIevery day you should either still be in version 0.x.x or on a separatedevelopment branch working on the next major version.

If even the tiniest backwards incompatible changes to the public API require a major version bump, won’t I end up at version 42.0.0 very rapidly?

This is a question of responsible development and foresight. Incompatiblechanges should not be introduced lightly to software that has a lot ofdependent code. The cost that must be incurred to upgrade can be significant.Having to bump major versions to release incompatible changes means you’llthink through the impact of your changes, and evaluate the cost/benefit ratioinvolved.

Documenting the entire public API is too much work!

It is your responsibility as a professional developer to properly documentsoftware that is intended for use by others. Managing software complexity is ahugely important part of keeping a project efficient, and that’s hard to do ifnobody knows how to use your software, or what methods are safe to call. Inthe long run, Semantic Versioning, and the insistence on a well defined publicAPI can keep everyone and everything running smoothly.

What do I do if I accidentally release a backwards incompatible change as a minor version?

As soon as you realize that you’ve broken the Semantic Versioning spec, fixthe problem and release a new minor version that corrects the problem andrestores backwards compatibility. Remember, it is unacceptable to modifyversioned releases, even under this circumstance. If it’s appropriate,document the offending version and inform your users of the problem so thatthey are aware of the offending version.

What should I do if I update my own dependencies without changing the public API?

That would be considered compatible since it does not affect the public API.Software that explicitly depends on the same dependencies as your packageshould have their own dependency specifications and the author will notice anyconflicts. Determining whether the change is a patch level or minor levelmodification depends on whether you updated your dependencies in order to fixa bug or introduce new functionality. I would usually expect additional codefor the latter instance, in which case it’s obviously a minor level increment.

What should I do if the bug that is being fixed returns the code to being compliant with the public API (i.e. the code was incorrectly out of sync with the public API documentation)?

Use your best judgment. If you have a huge audience that will be drasticallyimpacted by changing the behavior back to what the public API intended, thenit may be best to perform a major version release, even though the fix couldstrictly be considered a patch release. Remember, Semantic Versioning is allabout conveying meaning by how the version number changes. If these changesare important to your users, use the version number to inform them.

About

The Semantic Versioning specification is authored by Tom Preston-Werner, inventor of Gravatars and cofounder of GitHub.

If you’d like to leave feedback, please open an issue on GitHub.

License

Creative Commons ― CC BY 3.0http://creativecommons.org/licenses/by/3.0/

-->

By Andrew Marshall
Principal Security Program Manager
Microsoft Corporation

Executive Summary

This document presents the latest guidance on rapidly identifying and removing Transport Layer Security (TLS) protocol version 1.0 dependencies in software built on top of Microsoft operating systems, following up with details on product changes and new features delivered by Microsoft to protect your own customers and online services. It is intended to be used as a starting point for building a migration plan to a TLS 1.2+ network environment. While the solutions discussed here may carry over and help with removing TLS 1.0 usage in non-Microsoft operating systems or crypto libraries, they are not a focus of this document.

TLS 1.0 is a security protocol first defined in 1999 for establishing encryption channels over computer networks. Microsoft has supported this protocol since Windows XP/Server 2003. While no longer the default security protocol in use by modern OSes, TLS 1.0 is still supported for backwards compatibility. Evolving regulatory requirements as well as new security vulnerabilities in TLS 1.0 provide corporations with the incentive to disable TLS 1.0 entirely.

Microsoft recommends customers get ahead of this issue by removing TLS 1.0 dependencies in their environments and disabling TLS 1.0 at the operating system level where possible. Given the length of time TLS 1.0 has been supported by the software industry, it is highly recommended that any TLS 1.0 deprecation plan include the following:

  • Code analysis to find/fix hardcoded instances of TLS 1.0 or older security protocols.

  • Network endpoint scanning and traffic analysis to identify operatingsystems using TLS 1.0 or older protocols.

  • Full regression testing through your entire application stack withTLS 1.0 disabled.

  • Migration of legacy operating systems and development libraries/frameworks to versions capable of negotiating TLS 1.2 by default.

  • Compatibility testing across operating systems used by your businessto identify any TLS 1.2 support issues.

  • Coordination with your own business partners and customers to notifythem of your move to deprecate TLS 1.0.

  • Understanding which clients may no longer be able to connect to your servers once TLS 1.0 is disabled.

The goal of this document is to provide recommendations which can help remove technical blockers to disabling TLS 1.0 while at the same time increasing visibility into the impact of this change to your own customers. Completing such investigations can help reduce the business impact of the next security vulnerability in TLS 1.0. For the purposes of this document, references to the deprecation of TLS 1.0 also include TLS 1.1.

Enterprise software developers have a strategic need to adopt more future-safe and agile solutions (otherwise known as Crypto Agility) to deal with future security protocol compromises. While this document proposes agile solutions to the elimination of TLS hardcoding, broader Crypto Agility solutions are beyond the scope of this document.

The Current State of Microsoft's TLS 1.0 implementation

Microsoft's TLS 1.0implementation is freeof known security vulnerabilities. Due to the potential for futureprotocol downgradeattacks and other TLS 1.0vulnerabilities not specific to Microsoft's implementation, it isrecommended that dependencies on all security protocols older than TLS1.2 be removed where possible (TLS 1.1/1.0/ SSLv3/SSLv2).

In planning for this migration to TLS 1.2+, developers and systemadministrators should be aware of the potential for protocol versionhardcoding in applications developed by their employees andpartners. Hardcoding here means that the TLS version is fixed to a version that is outdated and less secure than newer versions. TLS versions newer than the hardcoded version cannot be used without modifying the program in question. This class of problem cannot be addressed without source code changes and software update deployment. Protocol version hardcoding was commonplace in the past fortesting and supportability purposes as many different browsers andoperating systems had varying levels of TLS support.

Ensuring support for TLS 1.2 across deployed operating systems

Many operating systems have outdated TLS version defaults or supportceilings that need to be accounted for. Usage of Windows 8/Server 2012or later means that TLS 1.2 will be the default security protocolversion:

Figure 1: Security Protocol Support by OS Version

Windows OSSSLv2SSLv3TLS 1.0TLS 1.1TLS 1.2
Windows VistaEnabledEnabledDefaultNot SupportedNot Supported
Windows Server 2008EnabledEnabledDefaultDisabled*Disabled*
Windows 7 (WS2008 R2)EnabledEnabledDefaultDisabled*Disabled*
Windows 8 (WS2012)DisabledEnabledEnabledEnabledDefault
Windows 8.1 (WS2012 R2)DisabledEnabledEnabledEnabledDefault
Windows 10DisabledEnabledEnabledEnabledDefault
Windows Server 2016Not SupportedDisabledEnabledEnabledDefault
Version

*TLS 1.1/1.2 can be enabled on Windows Server 2008 via this optional Windows Update package.

For more information on TLS 1.0/1.1 deprecation in IE/Edge, see Modernizing TLS connections in Microsoft Edge and Internet Explorer 11, Site compatibility-impacting changes coming to Microsoft Edge and Disabling TLS/1.0 and TLS/1.1 in the new Edge Browser

A quick way to determine what TLS version will be requested by variousclients when connecting to your online services is by referring to theHandshake Simulation at Qualys SSL Labs.This simulation covers client OS/browser combinations acrossmanufacturers. See AppendixAat the end of this document for a detailed example showing the TLSprotocol versions negotiated by various simulated client OS/browsercombinations when connecting towww.microsoft.com.

If not already complete, it is highly recommended to conduct aninventory of operating systems used by your enterprise, customers andpartners (the latter two via outreach/communication or at least HTTPUser-Agent string collection). This inventory can be furthersupplemented by traffic analysis at your enterprise network edge. Insuch a situation, traffic analysis will yield the TLS versionssuccessfully negotiated by customers/partners connecting to yourservices, but the traffic itself will remain encrypted.

Microsoft's Engineering Improvements to eliminate TLS 1.0 dependencies

Since the v1 release of this document, Microsoft has shipped a number of software updates and new features in support of TLS 1.0 deprecation. These include:

  • IIS custom logging to correlate client IP/user agent string, service URI, TLS protocol version and cipher suite.

    • With this logging, admins can finally quantify their customers' exposure to weak TLS.
  • SecureScore - To help Office 365 tenant admins identify their own weak TLS usage, the SecureScore portal has been built to share this information as TLS 1.0 exited support in Office 365 in October 2018.

    • This portal provides Office 365 tenant admins with the valuable information they need to reach out to their own customers who may be unaware of their own TLS 1.0 dependencies.

    • Please visit https://securescore.microsoft.com/ for more information.

  • .Net Framework updates to eliminate app-level hardcoding and prevent framework-inherited TLS 1.0 dependencies.

  • Developer Guidance and software updates have been released to help customers identify and eliminate .Net dependencies on weak TLS: Transport Layer Security (TLS) best practices with the .NET Framework

    • FYI: All apps targeting .NET 4.5 or below are likely going to have to be modified in order to support TLS 1.2.
  • TLS 1.2 has been backported to Windows Server 2008 SP2 and XP POSReady 2009 to help customers with legacy obligations.

  • More announcements will be made in early 2019 and communicated in subsequent updates of this document.

Finding and fixing TLS 1.0 dependencies in code

For products using the Windows OS-provided cryptography libraries andsecurity protocols, the following steps should help identify anyhardcoded TLS 1.0 usage in your applications:

  1. Identify all instances ofAcquireCredentialsHandle().This helps reviewers get closer proximity to code blocks where TLSmay be hardcoded.

  2. Review any instances of theSecPkgContext_SupportedProtocolsandSecPkgContext_ConnectionInfostructures for hardcoded TLS.

  3. In native code, set any non-zero assignments ofgrbitEnabledProtocolsto zero. This allows the operating system to use its default TLSversion.

  4. Disable FIPSModeif it is enabled due to the potential for conflict with settingsrequired for explicitly disabling TLS 1.0/1.1 in this document. SeeAppendixB formore information.

  5. Update and recompile any applications using WinHTTP hosted on Server2012 or older.

    1. Managed apps – rebuild and retarget against the latest .NET Framework version

    2. Applications must add code to support TLS 1.2 viaWinHttpSetOption

  6. To cover all the bases, scan source code and online serviceconfiguration files for the patterns below corresponding toenumerated type values commonly used in TLS hardcoding:

    1. SecurityProtocolType

    2. SSLv2, SSLv23, SSLv3, TLS1, TLS 10, TLS11

    3. WINHTTP_FLAG_SECURE_PROTOCOL_

    4. SP_PROT_

    5. NSStreamSocketSecurityLevel

    6. PROTOCOL_SSL or PROTOCOL_TLS

The recommended solution in all cases above is to remove the hardcoded protocol version selection and defer to the operating system default. If you are using DevSkim, click here to see rules covering the above checks which you can use with your own code.

Update Windows PowerShell scripts or related registry settings

Windows PowerShell uses .NET Framework 4.5, which does not include TLS 1.2 as an available protocol. To work around this, two solutions are available:

Solutions (1) and (2) are mutually-exclusive, meaning they need not be implemented together.

Rebuild/retarget managed applications using the latest .Net Framework version

Applications using .NET framework versions prior to 4.7 may have limitations effectively capping support to TLS 1.0 regardless of the underlying OS defaults. Refer to the below diagram and https://docs.microsoft.com/dotnet/framework/network-programming/tls for more information.

SystemDefaultTLSVersion takes precedence over app-level targeting of TLS versions. The recommended best practice is to always defer to the OS default TLS version. It is also the only crypto-agile solution that lets your apps take advantage of future TLS 1.3 support.

If you are targeting older versions of .NET Framework such as 4.5.2 or 3.5, then by default your application will use the older and not recommended protocols such as SSL 3.0 or TLS 1.0. It is strongly recommended that you upgrade to newer versions of .NET Framework such as .NET Framework 4.6 or set the appropriate registry keys for 'UseStrongCrypto'.

Testing with TLS 1.2+

Following the fixes recommended in the section above, products should beregression-tested for protocol negotiation errors and compatibility withother operating systems in your enterprise.

  • The most common issue in this regression testing will be a TLSnegotiation failure due to a client connection attempt from anoperating system or browser that does not support TLS 1.2.

    • For example, a Vista client will fail to negotiate TLS with aserver configured for TLS 1.2+ as Vista's maximum supported TLSversion is 1.0. That client should be either upgraded ordecommissioned in a TLS 1.2+ environment.
  • Products using certificate-based Mutual TLS authentication mayrequire additional regression testing as the certificate-selectioncode associated with TLS 1.0 was less expressive than that for TLS1.2.

    • If a product negotiates MTLS with a certificate from anon-standard location (outside of the standard named certificatestores in Windows), then that code may need updating to ensurethe certificate is acquired correctly.
  • Service interdependencies should be reviewed for trouble spots.

    • Any services which interoperate with 3rd-partyservices should conduct additional interop testing with those3rd parties.

    • Any non-Windows applications or server operating systems in userequire investigation / confirmation that they can support TLS1.2. Scanning is the easiest way to determine this.

A simple blueprint for testing these changes in an online serviceconsists of the following:

Version 1.0.0.0

  1. Conduct a scan of production environment systems to identifyoperating systems which do not support TLS 1.2.

  2. Scan source code and online service configuration files forhardcoded TLS as described in 'Finding and fixing TLS 1.0dependencies incode'

  3. Update/recompile applications as required:

    1. Managed apps

      1. Rebuild against the latest .NET Framework version.

      2. Verify any usage of theSSLProtocolsenumeration is set to SSLProtocols.None in order to use OSdefault settings.

    2. WinHTTP apps – rebuild withWinHttpSetOptionto support TLS 1.2

  4. Start testing in a pre-production or staging environment with allsecurity protocols older than TLS 1.2 disabled viaregistry.

  5. Fix any remaining instances of TLS hardcoding as they areencountered in testing. Redeploy the software and perform a newregression test run.

Notifying partners of your TLS 1.0 deprecation plans

After TLS hardcoding is addressed and operating system/developmentframework updates are completed, should you opt to deprecate TLS 1.0 itwill be necessary to coordinate with customers and partners:

  • Early partner/customer outreach is essential to a successful TLS 1.0deprecation rollout. At a minimum this should consist of blogpostings, whitepapers or other web content.

  • Partners each need to evaluate their own TLS 1.2 readiness throughthe operating system/code scanning/regression testing initiativesdescribed in above sections.

Conclusion

Removing TLS 1.0 dependencies is a complicated issue to drive end toend. Microsoft and industry partners are taking action on this today toensure our entire product stack is more secure by default, from our OScomponents and development frameworks up to the applications/servicesbuilt on top of them. Following the recommendations made in thisdocument will help your enterprise chart the right course and know whatchallenges to expect. It will also help your own customers become moreprepared for thetransition.

Version 1.06 2k21

Appendix A: Handshake Simulation for various clients connecting to www.microsoft.com, courtesy SSLLabs.com

Version 1.02

Appendix B: Deprecating TLS 1.0/1.1 while retaining FIPS Mode

Follow the steps below if your network requires FIPS Mode but you alsowant to deprecate TLS 1.0/1.1:

  1. Configure TLS versions via theregistry,by setting 'Enabled' to zero for the unwanted TLS versions.

  2. Disable Curve 25519 (Server 2016 only) via Group Policy.

  3. Disable any cipher suites using algorithms that aren't allowed bythe relevant FIPS publication. For Server 2016 (assuming the defaultsettings are in effect) this is means disabling RC4, PSK and NULLciphers.

Contributors/Thanks to

Mark Cartwright
Bryan Sullivan
Patrick Jungles
Michael Scovetta
Tony Rice
David LeBlanc
Mortimer Cook
Daniel Sommerfeld
Andrei Popov
Michiko Short
Justin Burke
Gov Maharaj
Brad Turner
Sean Stevenson

Coments are closed
Scroll to top