metanorma-iso 2.0.4 → 2.0.5

Sign up to get free protection for your applications and to get access to all the features.
Files changed (32) hide show
  1. checksums.yaml +4 -4
  2. data/lib/isodoc/iso/html/wordstyle.css +20 -0
  3. data/lib/isodoc/iso/html/wordstyle.scss +20 -0
  4. data/lib/isodoc/iso/i18n-en.yaml +7 -2
  5. data/lib/isodoc/iso/i18n-fr.yaml +5 -2
  6. data/lib/isodoc/iso/i18n-ru.yaml +5 -2
  7. data/lib/isodoc/iso/i18n-zh-Hans.yaml +6 -2
  8. data/lib/isodoc/iso/init.rb +1 -2
  9. data/lib/isodoc/iso/iso.amendment.xsl +632 -317
  10. data/lib/isodoc/iso/iso.international-standard.xsl +632 -317
  11. data/lib/isodoc/iso/presentation_xml_convert.rb +58 -21
  12. data/lib/metanorma/iso/cleanup.rb +37 -10
  13. data/lib/metanorma/iso/processor.rb +14 -7
  14. data/lib/metanorma/iso/validate.rb +29 -1
  15. data/lib/metanorma/iso/validate_image.rb +3 -3
  16. data/lib/metanorma/iso/validate_list.rb +107 -0
  17. data/lib/metanorma/iso/validate_section.rb +39 -32
  18. data/lib/metanorma/iso/validate_style.rb +32 -2
  19. data/lib/metanorma/iso/validate_title.rb +13 -1
  20. data/lib/metanorma/iso/version.rb +1 -1
  21. data/spec/isodoc/inline_spec.rb +127 -10
  22. data/spec/isodoc/postproc_spec.rb +2 -4
  23. data/spec/isodoc/terms_spec.rb +4 -4
  24. data/spec/metanorma/base_spec.rb +1 -0
  25. data/spec/metanorma/cleanup_spec.rb +11 -11
  26. data/spec/metanorma/refs_spec.rb +332 -61
  27. data/spec/metanorma/section_spec.rb +15 -20
  28. data/spec/metanorma/validate_spec.rb +423 -13
  29. data/spec/spec_helper.rb +6 -4
  30. data/spec/vcr_cassettes/docrels.yml +393 -0
  31. data/spec/vcr_cassettes/withdrawn_iso.yml +301 -0
  32. metadata +5 -2
data/spec/vcr_cassettes/withdrawn_iso.yml ADDED
@@ -0,0 +1,301 @@
1
+ ---
2
+ http_interactions:
3
+ - request:
4
+ method: post
5
+ uri: https://jcl49wv5ar-dsn.algolia.net/1/indexes/all_en/query
6
+ body:
7
+ encoding: UTF-8
8
+ string: '{"query":"ISO/IEC 27005","hitsPerPage":100,"filters":"category:standard"}'
9
+ headers:
10
+ User-Agent:
11
+ - Algolia for Ruby (2.1.1), Ruby (3.0.3)
12
+ X-Algolia-Api-Key:
13
+ - dd1b9e1ab383f4d4817d29cd5e96d3f0
14
+ X-Algolia-Application-Id:
15
+ - JCL49WV5AR
16
+ Content-Type:
17
+ - application/json; charset=utf-8
18
+ Accept-Encoding:
19
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
20
+ Accept:
21
+ - "*/*"
22
+ Connection:
23
+ - keep-alive
24
+ Keep-Alive:
25
+ - '30'
26
+ response:
27
+ status:
28
+ code: 200
29
+ message: OK
30
+ headers:
31
+ Server:
32
+ - nginx
33
+ Date:
34
+ - Thu, 24 Feb 2022 13:51:36 GMT
35
+ Content-Type:
36
+ - application/json; charset=UTF-8
37
+ Transfer-Encoding:
38
+ - chunked
39
+ Connection:
40
+ - keep-alive
41
+ X-Alg-Pt:
42
+ - '1'
43
+ Accept-Encoding:
44
+ - deflate, gzip
45
+ Cache-Control:
46
+ - no-store
47
+ Access-Control-Allow-Origin:
48
+ - "*"
49
+ Timing-Allow-Origin:
50
+ - "*"
51
+ X-Content-Type-Options:
52
+ - nosniff
53
+ Strict-Transport-Security:
54
+ - max-age=31536000; includeSubDomains; preload
55
+ Content-Disposition:
56
+ - inline; filename=a.txt
57
+ body:
58
+ encoding: ASCII-8BIT
59
+ string: !binary |-
60
+ {"hits":[{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/52/75281","uuid":"ea5ef7aa-c325-4d3d-84cc-b40975c0f48b","title":"ISO/IEC 27005:2018 Information technology — Security techniques — Information security risk management","status":"Published","year":2020,"order":11,"text":"This document provides guidelines for information security risk management. This document supports the general concepts specified in ISO/IEC 27001 and is designed to assist the satisfactory implementation of information security based on a risk management approach. Knowledge of the concepts, models, processes and terminologies described in ISO/IEC 27001 and ISO/IEC 27002 is important for a complete understanding of this document. This document is applicable to all types of organizations (e.g. commercial enterprises, government agencies, non-profit organizations) which intend to manage risks that can compromise the organization's information security. ","objectID":"75281_0","_highlightResult":{"title":{"value":"<em>ISO</em>/<em>IEC</em> <em>27005</em>:2018 Information technology — Security techniques — Information security risk management","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","iec","27005"]},"text":{"value":"This document provides guidelines for information security risk management. This document supports the general concepts specified in <em>ISO</em>/<em>IEC</em> 27001 and is designed to assist the satisfactory implementation of information security based on a risk management approach. Knowledge of the concepts, models, processes and terminologies described in <em>ISO</em>/<em>IEC</em> 27001 and <em>ISO</em>/<em>IEC</em> 27002 is important for a complete understanding of this document. This document is applicable to all types of organizations (e.g. commercial enterprises, government agencies, non-profit organizations) which intend to manage risks that can compromise the organization's information security. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso","iec"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/05/67/56742","uuid":"346f98bd-59fd-4ca5-aa91-55caa63beb11","title":"ISO/IEC 27005:2011 Information technology — Security techniques — Information security risk management","status":"Withdrawn","year":2018,"order":100,"text":"ISO/IEC 27005:2011 provides guidelines for information security risk management. It supports the general concepts specified in ISO/IEC 27001 and is designed to assist the satisfactory implementation of information security based on a risk management approach. Knowledge of the concepts, models, processes and terminologies described in ISO/IEC 27001 and ISO/IEC 27002 is important for a complete understanding of ISO/IEC 27005:2011. ISO/IEC 27005:2011 is applicable to all types of organizations (e.g. commercial enterprises, government agencies, non-profit organizations) which intend to manage risks that could compromise the organization's information security. ","objectID":"56742_0","_highlightResult":{"title":{"value":"<em>ISO</em>/<em>IEC</em> <em>27005</em>:2011 Information technology — Security techniques — Information security risk management","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","iec","27005"]},"text":{"value":"<em>ISO</em>/<em>IEC</em> <em>27005</em>:2011 provides guidelines for information security risk management. It supports the general concepts specified in <em>ISO</em>/<em>IEC</em> 27001 and is designed to assist the satisfactory implementation of information security based on a risk management approach. Knowledge of the concepts, models, processes and terminologies described in <em>ISO</em>/<em>IEC</em> 27001 and <em>ISO</em>/<em>IEC</em> 27002 is important for a complete understanding of <em>ISO</em>/<em>IEC</em> <em>27005</em>:2011. <em>ISO</em>/<em>IEC</em> <em>27005</em>:2011 is applicable to all types of organizations (e.g. commercial enterprises, government agencies, non-profit organizations) which intend to manage risks that could compromise the organization's information security. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","iec","27005"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/04/21/42107","uuid":"07b8f3f1-f86d-4439-837e-f907143165dc","title":"ISO/IEC 27005:2008 Information technology — Security techniques — Information security risk management","status":"Withdrawn","year":2011,"order":100,"text":"ISO/IEC 27005:2008 provides guidelines for information security risk management. It supports the general concepts specified in ISO/IEC 27001 and is designed to assist the satisfactory implementation of information security based on a risk management approach. Knowledge of the concepts, models, processes and terminologies described in ISO/IEC 27001 and ISO/IEC 27002 is important for a complete understanding of ISO/IEC 27005:2008. ISO/IEC 27005:2008 is applicable to all types of organizations (e.g. commercial enterprises, government agencies, non-profit organizations) which intend to manage risks that could compromise the organization's information security. ","objectID":"42107_0","_highlightResult":{"title":{"value":"<em>ISO</em>/<em>IEC</em> <em>27005</em>:2008 Information technology — Security techniques — Information security risk management","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","iec","27005"]},"text":{"value":"<em>ISO</em>/<em>IEC</em> <em>27005</em>:2008 provides guidelines for information security risk management. It supports the general concepts specified in <em>ISO</em>/<em>IEC</em> 27001 and is designed to assist the satisfactory implementation of information security based on a risk management approach. Knowledge of the concepts, models, processes and terminologies described in <em>ISO</em>/<em>IEC</em> 27001 and <em>ISO</em>/<em>IEC</em> 27002 is important for a complete understanding of <em>ISO</em>/<em>IEC</em> <em>27005</em>:2008. <em>ISO</em>/<em>IEC</em> <em>27005</em>:2008 is applicable to all types of organizations (e.g. commercial enterprises, government agencies, non-profit organizations) which intend to manage risks that could compromise the organization's information security. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","iec","27005"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/08/05/80585","uuid":"1637eb77-afed-4f4a-97d2-2c3b6cb97e69","title":"ISO/IEC DIS 27005 Information security, cybersecurity and privacy protection — Guidance on managing information security risks","status":"Under development","year":2022,"order":12,"objectID":"80585_0","_highlightResult":{"title":{"value":"<em>ISO</em>/<em>IEC</em> DIS <em>27005</em> Information security, cybersecurity and privacy protection — Guidance on managing information security risks","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","iec","27005"]}}}],"nbHits":4,"page":0,"nbPages":1,"hitsPerPage":100,"exhaustiveNbHits":true,"exhaustiveTypo":true,"query":"ISO/IEC 27005","params":"query=ISO%2FIEC+27005&hitsPerPage=100&filters=category%3Astandard","processingTimeMS":1}
61
+ http_version:
62
+ recorded_at: Thu, 24 Feb 2022 13:51:36 GMT
63
+ - request:
64
+ method: post
65
+ uri: https://jcl49wv5ar-dsn.algolia.net/1/indexes/all_en/query
66
+ body:
67
+ encoding: UTF-8
68
+ string: '{"query":"ISO 683-3","hitsPerPage":100,"filters":"category:standard"}'
69
+ headers:
70
+ User-Agent:
71
+ - Algolia for Ruby (2.1.1), Ruby (3.0.3)
72
+ X-Algolia-Api-Key:
73
+ - dd1b9e1ab383f4d4817d29cd5e96d3f0
74
+ X-Algolia-Application-Id:
75
+ - JCL49WV5AR
76
+ Content-Type:
77
+ - application/json; charset=utf-8
78
+ Accept-Encoding:
79
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
80
+ Accept:
81
+ - "*/*"
82
+ Connection:
83
+ - keep-alive
84
+ Keep-Alive:
85
+ - '30'
86
+ response:
87
+ status:
88
+ code: 200
89
+ message: OK
90
+ headers:
91
+ Server:
92
+ - nginx
93
+ Date:
94
+ - Thu, 24 Feb 2022 13:51:36 GMT
95
+ Content-Type:
96
+ - application/json; charset=UTF-8
97
+ Transfer-Encoding:
98
+ - chunked
99
+ Connection:
100
+ - keep-alive
101
+ X-Alg-Pt:
102
+ - '1'
103
+ Accept-Encoding:
104
+ - deflate, gzip
105
+ Cache-Control:
106
+ - no-store
107
+ Access-Control-Allow-Origin:
108
+ - "*"
109
+ Timing-Allow-Origin:
110
+ - "*"
111
+ X-Content-Type-Options:
112
+ - nosniff
113
+ Strict-Transport-Security:
114
+ - max-age=31536000; includeSubDomains; preload
115
+ Content-Disposition:
116
+ - inline; filename=a.txt
117
+ body:
118
+ encoding: ASCII-8BIT
119
+ string: !binary |-
120
+ {"hits":[{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/82/78216","uuid":"d4ee744b-3b21-4f6d-9d2a-8c4b94a1c502","title":"ISO 683-3:2022 Heat-treatable steels, alloy steels and free-cutting steels — Part 3: Case-hardening steels","status":"Published","year":2022,"order":11,"text":"This document specifies the technical delivery requirements for —    semi-finished products, hot formed (e.g. blooms, billets, slabs) (see NOTE 1), —    bars (see NOTE 1), —    wire rod, —    finished flat products, and —    hammer or drop forgings (see NOTE 1) manufactured from the case-hardening non-alloy or alloy steels listed in Table 3 and supplied in one of the heat-treatment conditions given for the different types of products in Table 1 and in one of the surface conditions given in Table 2. The steels are, in general, intended for the manufacture of case-hardened machine parts. NOTE 1   Hammer-forged semi-finished products (blooms, billets, slabs, etc.), seamless rolled rings and hammerforged bars are covered under semi-finished products or bars and not under the term “hammer and drop forgings”. NOTE 2   For International Standards relating to steels conforming with the requirements for the chemical composition in Table 3, however, supplied in other product forms or treatment conditions than given above or intended for special applications, and for other related International Standards, see the Bibliography. ","objectID":"78216_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>683-3</em>:2022 Heat-treatable steels, alloy steels and free-cutting steels — Part 3: Case-hardening steels","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","683","3"]},"text":{"value":"This document specifies the technical delivery requirements for —    semi-finished products, hot formed (e.g. blooms, billets, slabs) (see NOTE 1), —    bars (see NOTE 1), —    wire rod, —    finished flat products, and —    hammer or drop forgings (see NOTE 1) manufactured from the case-hardening non-alloy or alloy steels listed in Table 3 and supplied in one of the heat-treatment conditions given for the different types of products in Table 1 and in one of the surface conditions given in Table 2. The steels are, in general, intended for the manufacture of case-hardened machine parts. NOTE 1   Hammer-forged semi-finished products (blooms, billets, slabs, etc.), seamless rolled rings and hammerforged bars are covered under semi-finished products or bars and not under the term “hammer and drop forgings”. NOTE 2   For International Standards relating to steels conforming with the requirements for the chemical composition in Table 3, however, supplied in other product forms or treatment conditions than given above or intended for special applications, and for other related International Standards, see the Bibliography. ","matchLevel":"none","matchedWords":[]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/63/76389","uuid":"20e6476e-d33b-4db6-a38a-79926f6e83e1","title":"ISO 683-3:2019 Heat-treatable steels, alloy steels and free-cutting steels — Part 3: Case-hardening steels","status":"Withdrawn","year":2022,"order":100,"text":"This document specifies the technical delivery requirements for —          semi-finished products, hot formed, e.g. blooms, billets, slabs (see NOTE 1), —          bars (see NOTE 1), —          wire rod, —          finished flat products, and —          hammer or drop forgings (see NOTE 1) manufactured from the case-hardening non-alloy or alloy steels listed in Table 3 and supplied in one of the heat-treatment conditions given for the different types of products in Table 1 and in one of the surface conditions given in Table 2. The steels are, in general, intended for the manufacture of case-hardened machine parts. NOTE 1    Hammer-forged semi-finished products (blooms, billets, slabs, etc.), seamless rolled rings and hammer-forged bars are covered under semi-finished products or bars and not under the term \"hammer and drop forgings\". NOTE 2    For International Standards relating to steels complying with the requirements for the chemical composition in Table 3, however, supplied in other product forms or treatment conditions than given above or intended for special applications, and for other related International Standards, see the Bibliography. In special cases, variations in these technical delivery requirements or additions to them can form the subject of an agreement at the time of enquiry and order (see 5.2 and Annex A). In addition to this document, the general technical delivery requirements of ISO 404 are applicable. ","objectID":"76389_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>683-3</em>:2019 Heat-treatable steels, alloy steels and free-cutting steels — Part 3: Case-hardening steels","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","683","3"]},"text":{"value":"This document specifies the technical delivery requirements for —          semi-finished products, hot formed, e.g. blooms, billets, slabs (see NOTE 1), —          bars (see NOTE 1), —          wire rod, —          finished flat products, and —          hammer or drop forgings (see NOTE 1) manufactured from the case-hardening non-alloy or alloy steels listed in Table 3 and supplied in one of the heat-treatment conditions given for the different types of products in Table 1 and in one of the surface conditions given in Table 2. The steels are, in general, intended for the manufacture of case-hardened machine parts. NOTE 1    Hammer-forged semi-finished products (blooms, billets, slabs, etc.), seamless rolled rings and hammer-forged bars are covered under semi-finished products or bars and not under the term \"hammer and drop forgings\". NOTE 2    For International Standards relating to steels complying with the requirements for the chemical composition in Table 3, however, supplied in other product forms or treatment conditions than given above or intended for special applications, and for other related International Standards, see the Bibliography. In special cases, variations in these technical delivery requirements or additions to them can form the subject of an agreement at the time of enquiry and order (see 5.2 and Annex A). In addition to this document, the general technical delivery requirements of <em>ISO</em> 404 are applicable. ","matchLevel":"partial","fullyHighlighted":false,"matchedWords":["iso"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/07/06/70644","uuid":"d1ed4c5f-5259-4ade-8c91-8c852f46f70f","title":"ISO 683-3:2016 Heat-treatable steels, alloy steels and free-cutting steels — Part 3: Case-hardening steels","status":"Withdrawn","year":2019,"order":100,"text":"ISO 683-3:2016 specifies the technical delivery requirements for -      semi-finished products, hot formed, e.g. blooms, billets, slabs (see Note 1), -      bars (see Note 1), -      wire rod, -      finished flat products, and -      hammer or drop forgings (see Note 1) manufactured from the case-hardening non-alloy or alloy steels listed in Table 3 and supplied in one of the heat-treatment conditions given for the different types of products in Table 1 and in one of the surface conditions given in Table 2. The steels are, in general, intended for the manufacture of case-hardened (see 3.1) machine parts. NOTE 1       Hammer-forged semi-finished products (blooms, billets, slabs, etc.), seamless rolled rings and hammer-forged bars are covered under semi-finished products or bars and not under the term \"hammer and drop forgings\". NOTE 2       For International Standards relating to steels complying with the requirements for the chemical composition in Table 3, however, supplied in other product forms or treatment conditions than given above or intended for special applications, and for other related International Standards, see the Bibliography. In special cases, variations in these technical delivery requirements or additions to them can form the subject of an agreement at the time of enquiry and order (see 5.2 and Annex A). In addition to ISO 683-3:2016, the general technical delivery requirements of ISO 404 are applicable. ","objectID":"70644_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>683-3</em>:2016 Heat-treatable steels, alloy steels and free-cutting steels — Part 3: Case-hardening steels","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","683","3"]},"text":{"value":"<em>ISO</em> <em>683-3</em>:2016 specifies the technical delivery requirements for -      semi-finished products, hot formed, e.g. blooms, billets, slabs (see Note 1), -      bars (see Note 1), -      wire rod, -      finished flat products, and -      hammer or drop forgings (see Note 1) manufactured from the case-hardening non-alloy or alloy steels listed in Table 3 and supplied in one of the heat-treatment conditions given for the different types of products in Table 1 and in one of the surface conditions given in Table 2. The steels are, in general, intended for the manufacture of case-hardened (see 3.1) machine parts. NOTE 1       Hammer-forged semi-finished products (blooms, billets, slabs, etc.), seamless rolled rings and hammer-forged bars are covered under semi-finished products or bars and not under the term \"hammer and drop forgings\". NOTE 2       For International Standards relating to steels complying with the requirements for the chemical composition in Table 3, however, supplied in other product forms or treatment conditions than given above or intended for special applications, and for other related International Standards, see the Bibliography. In special cases, variations in these technical delivery requirements or additions to them can form the subject of an agreement at the time of enquiry and order (see 5.2 and Annex A). In addition to <em>ISO</em> <em>683-3</em>:2016, the general technical delivery requirements of <em>ISO</em> 404 are applicable. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","683","3"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/06/55/65531","uuid":"bcdd1ca4-4d94-49b0-8712-466169e125b9","title":"ISO 683-3:2014 Heat-treatable steels, alloy steels and free-cutting steels — Part 3: Case-hardening steels","status":"Withdrawn","year":2016,"order":100,"text":"ISO 683-3:2014 specifies the technical delivery requirements for semi-finished products, hot formed, e.g. blooms, billets, slabs, for bars, wire rod, finished flat products, and hammer or drop forgings manufactured from case-hardening non-alloy or alloy steels and supplied in one of the heat-treatment conditions given for the different types of products and in one of the surface conditions given. The steels are, in general, intended for the manufacture of case-hardened machine parts. ","objectID":"65531_0","_highlightResult":{"title":{"value":"<em>ISO</em> <em>683-3</em>:2014 Heat-treatable steels, alloy steels and free-cutting steels — Part 3: Case-hardening steels","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","683","3"]},"text":{"value":"<em>ISO</em> <em>683-3</em>:2014 specifies the technical delivery requirements for semi-finished products, hot formed, e.g. blooms, billets, slabs, for bars, wire rod, finished flat products, and hammer or drop forgings manufactured from case-hardening non-alloy or alloy steels and supplied in one of the heat-treatment conditions given for the different types of products and in one of the surface conditions given. The steels are, in general, intended for the manufacture of case-hardened machine parts. ","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","683","3"]}}},{"category":"standard","path":"/sites/isoorg/contents/data/standard/00/48/4856","uuid":"ab0a7287-9338-4dc6-8e52-845f25287a72","title":"ISO/R 683-3:1970 Heat-treated steels, alloy steels and free-cutting steels — Part 3: Wrought quenched and tempered unalloyed steels with controlled sulphur content","status":"Withdrawn","year":1987,"order":100,"objectID":"4856_0","_highlightResult":{"title":{"value":"<em>ISO</em>/R <em>683-3</em>:1970 Heat-treated steels, alloy steels and free-cutting steels — Part 3: Wrought quenched and tempered unalloyed steels with controlled sulphur content","matchLevel":"full","fullyHighlighted":false,"matchedWords":["iso","683","3"]}}}],"nbHits":5,"page":0,"nbPages":1,"hitsPerPage":100,"exhaustiveNbHits":true,"exhaustiveTypo":true,"query":"ISO 683-3","params":"query=ISO+683-3&hitsPerPage=100&filters=category%3Astandard","processingTimeMS":1}
121
+ http_version:
122
+ recorded_at: Thu, 24 Feb 2022 13:51:36 GMT
123
+ - request:
124
+ method: get
125
+ uri: https://www.iso.org/contents/data/standard/07/52/75281.html
126
+ body:
127
+ encoding: US-ASCII
128
+ string: ''
129
+ headers:
130
+ Accept-Encoding:
131
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
132
+ Accept:
133
+ - "*/*"
134
+ User-Agent:
135
+ - Ruby
136
+ Host:
137
+ - www.iso.org
138
+ response:
139
+ status:
140
+ code: 301
141
+ message: ''
142
+ headers:
143
+ Expires:
144
+ - Wed, 09 May 1979 05:30:00 GMT
145
+ Cache-Control:
146
+ - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
147
+ Pragma:
148
+ - no-cache
149
+ Set-Cookie:
150
+ - BIGipServerpool_prod_iso_www-jahia=730354058.36895.0000; path=/; Httponly;
151
+ Secure
152
+ - JSESSIONID=08945398A923C6626EF770AD91B863D0; Path=/; Secure; HttpOnly
153
+ Location:
154
+ - "/standard/75281.html"
155
+ Content-Length:
156
+ - '0'
157
+ Date:
158
+ - Thu, 24 Feb 2022 13:51:38 GMT
159
+ Strict-Transport-Security:
160
+ - max-age=31536000; includeSubDomains
161
+ body:
162
+ encoding: UTF-8
163
+ string: ''
164
+ http_version:
165
+ recorded_at: Thu, 24 Feb 2022 13:51:38 GMT
166
+ - request:
167
+ method: get
168
+ uri: https://www.iso.org/contents/data/standard/07/63/76389.html
169
+ body:
170
+ encoding: US-ASCII
171
+ string: ''
172
+ headers:
173
+ Accept-Encoding:
174
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
175
+ Accept:
176
+ - "*/*"
177
+ User-Agent:
178
+ - Ruby
179
+ Host:
180
+ - www.iso.org
181
+ response:
182
+ status:
183
+ code: 301
184
+ message: ''
185
+ headers:
186
+ Expires:
187
+ - Wed, 09 May 1979 05:30:00 GMT
188
+ Cache-Control:
189
+ - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
190
+ Pragma:
191
+ - no-cache
192
+ Set-Cookie:
193
+ - BIGipServerpool_prod_iso_www-jahia=730354058.36895.0000; path=/; Httponly;
194
+ Secure
195
+ - JSESSIONID=5326871916E04BC1307A5E68E15769F1; Path=/; Secure; HttpOnly
196
+ Location:
197
+ - "/standard/76389.html"
198
+ Content-Length:
199
+ - '0'
200
+ Date:
201
+ - Thu, 24 Feb 2022 13:51:38 GMT
202
+ Strict-Transport-Security:
203
+ - max-age=31536000; includeSubDomains
204
+ body:
205
+ encoding: UTF-8
206
+ string: ''
207
+ http_version:
208
+ recorded_at: Thu, 24 Feb 2022 13:51:38 GMT
209
+ - request:
210
+ method: get
211
+ uri: https://www.iso.org/standard/76389.html
212
+ body:
213
+ encoding: US-ASCII
214
+ string: ''
215
+ headers:
216
+ Accept-Encoding:
217
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
218
+ Accept:
219
+ - "*/*"
220
+ User-Agent:
221
+ - Ruby
222
+ Host:
223
+ - www.iso.org
224
+ response:
225
+ status:
226
+ code: 200
227
+ message: ''
228
+ headers:
229
+ Expires:
230
+ - Wed, 09 May 1979 05:30:00 GMT
231
+ Cache-Control:
232
+ - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
233
+ Pragma:
234
+ - no-cache
235
+ Set-Cookie:
236
+ - BIGipServerpool_prod_iso_www-jahia=730354058.36895.0000; path=/; Httponly;
237
+ Secure
238
+ - JSESSIONID=7DA7D966818CB8894060B1A24B1C97CB; Path=/; Secure; HttpOnly
239
+ Vary:
240
+ - accept-encoding
241
+ Content-Type:
242
+ - text/html;charset=UTF-8
243
+ Transfer-Encoding:
244
+ - chunked
245
+ Date:
246
+ - Thu, 24 Feb 2022 14:51:41 CET
247
+ Strict-Transport-Security:
248
+ - max-age=31536000; includeSubDomains
249
+ body:
250
+ encoding: ASCII-8BIT
251
+ string: !binary |-
252
+ <!DOCTYPE html>


<html lang="en">
  <head>
    
    <script>
      dataLayer = [{
        'pageType': 'its:standard',
        'pageLanguage': 'en'
      }];
    </script>

    <!-- Google Tag Manager -->
    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
      j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
      'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
    })(window,document,'script','dataLayer','GTM-TFGKQQB');</script>
    <!-- End Google Tag Manager -->

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>ISO - ISO 683-3:2019 - Heat-treatable steels, alloy steels and free-cutting steels — Part 3: Case-hardening steels</title>

    
      <!--
      <link rel="preconnect" href="https://cdn.iso.org/" crossorigin />
      <link rel="preload" as="script" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.js" crossorigin />
      <link rel="preload" as="style" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.css" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/bootstrap/3.3.2/glyphicons-halflings-regular.woff2" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Bold.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Normal.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-NormalIta.woff" crossorigin />
      -->

    

    <link rel="canonical" href="https://www.iso.org/standard/76389.html" />

    <!-- start favicons -->
    <link rel="apple-touch-icon-precomposed" href="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/apple-touch-icon-152x152-precomposed.png">
    <link rel="shortcut icon" href="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/favicon.ico">
    <meta name="msapplication-TileColor" content="#eee">
    <meta name="msapplication-TileImage" content="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/mstile-144x144.png">
    <!-- end favicons -->

    
    <meta name="theme-color" content="#333">

  
<script type="text/javascript">
var contextJsParameters={contextPath:"",lang:"en",uilang:"en",siteUuid:"439146f8-677e-4dde-b6c6-b692b7534f52",wcag:false,ckeCfg:""}; var CKEDITOR_BASEPATH="/modules/ckeditor/javascript/"; var scayt_custom_params=new Array(); scayt_custom_params['sLang']='en_US';
</script>
<link id="staticAssetCSS0" rel="stylesheet" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.css" media="screen,print,handheld" type="text/css"/>
<link id="staticAssetCSS1" rel="stylesheet" href="/modules/assets/css/languageSwitchingLinks.css?1532003505766" media="screen" type="text/css"/>
<link id="staticAssetCSS2" rel="stylesheet" href="/modules/iso-jahia-service-module/css/catalogue.css?1642771880426" media="screen" type="text/css"/>
<script id="staticAssetJavascript0" type="text/javascript" src="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.js"  ></script>
<script id="staticAssetJavascript1" type="text/javascript" src="/modules/iso-jahia-service-module/javascript/catalogue.js?1642771880426"  ></script>
<script id="staticAssetJavascript2" type="text/javascript" src="/modules/isoorg-template/javascript/custom.js?1635768247679"  ></script>

    <meta name="category" content="w" />
  
    <meta name="pubdate" content="20220121" />
  

  <!-- Twitter Card data -->
  <meta name="twitter:site" content="@isostandards" />

  <!-- Open Graph data -->
  <meta property="og:site_name" content="ISO" />
  <meta property="og:url" content="https://www.iso.org/cms/render/live/en/sites/isoorg/contents/data/standard/07/63/76389.html" />
  
    <meta property="og:type" content="website" />
  
    <!-- Thumbnail image (for twitter and Open Graph) -->
    <meta name="thumbnail" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta name="twitter:card" content="summary" />
    <meta name="twitter:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image:alt" content="ISO logo" />
  
    <!-- Title (for twitter and Open Graph) -->
    <meta name="twitter:title" content="ISO 683-3:2019" />
    <meta property="og:title" content="ISO 683-3:2019" />
  
    <!-- Description (for google, twitter and Open Graph) -->
    <meta name="twitter:description" content="Heat-treatable steels, alloy steels and free-cutting steels — Part 3: Case-hardening steels" />
    <meta property="og:description" content="Heat-treatable steels, alloy steels and free-cutting steels — Part 3: Case-hardening steels" />
    <meta name="description" content="Heat-treatable steels, alloy steels and free-cutting steels — Part 3: Case-hardening steels" />
  

  <!-- Facebook admins : Lionel,Maria -->
  <meta property="fb:admins" content="100001116079676,100001440003305" />

  

</head>
  <body class="theme-red" id="offcanvas-content">
    <!-- Google Tag Manager (noscript) -->
    <noscript aria-hidden="true"><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TFGKQQB" height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
    <!-- End Google Tag Manager (noscript) -->
    <a class="skip-navigation btn btn-info sr-only sr-only-focusable" href="#content">Skip to main content</a>
    <!-- Header ISO.ORG -->
    <header role="banner" aria-label="Header" class="theme-red header-acer " id="page-top">
      <div class="container">
        <div class="navbar navbar-inverse navbar-fixed-top navbar-default navbar-acer theme-red" data-spy="affix" data-offset-top="200">
          <button role="button" id="offcanvas-btn" class="btn btn-transparent pull-right" data-toggle="open-offcanvas"><span class="glyphicon glyphicon-menu-hamburger"></span><span class="hidden-xxs"> Menu</span></button>

          <!-- SIDE NAVIGATION -->
          <nav role="navigation" aria-label="Side Navigation" class="sidenav" id="offcanvas-panel"><ul role="menubar" class="nav navbar-nav nav-level1"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/standards.html" class="dropdown-toggle" role="button">Standards</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/benefits-of-standards.html" class="dropdown-toggle" role="button">Benefits</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-and-smes.html" class="dropdown-toggle" role="button">SMEs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-consumers.html" class="dropdown-toggle" role="button">Consumers</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-policy-makers.html" class="dropdown-toggle" role="button">ISO and policy makers</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/standards-in-action.html" class="dropdown-toggle" role="button">Standards in action</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html" class="dropdown-toggle" role="button">Popular standards</a></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/conformity-assessment.html" class="dropdown-toggle" role="button">Certification & conformity</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/certification.html" class="dropdown-toggle" role="button">Certification</a></li><li role="none" class="noChildren"><a role="menuitem" href="/casco.html" class="dropdown-toggle" role="button">CASCO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/the-iso-survey.html" class="dropdown-toggle" role="button">The ISO Survey</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources-for-conformity-assessment.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html" class="dropdown-toggle" role="button">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/about-us.html" class="dropdown-toggle" role="button">About us</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/what-we-do.html" class="dropdown-toggle" role="button">What we do</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/developing-standards.html"  class="dropdown-toggle" role="button">Developing standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/research-and-education.html" class="dropdown-toggle" role="button">Research</a></li><li role="none" class="noChildren"><a role="menuitem" href="/capacity-building.html" class="dropdown-toggle" role="button">Capacity building</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/education-about-standards.html" class="dropdown-toggle" role="button">Education about standards</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html" class="dropdown-toggle" role="button">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html" class="dropdown-toggle" role="button">Members</a></li><li role="none" class="noChildren"><a role="menuitem" href="/announcements.html" class="dropdown-toggle" role="button">Announcements</a></li><li role="none" class="hasChildren dropdown lastInLevel"><a role="menuitem" href="/strategy2030.html" class="dropdown-toggle" role="button">Strategy</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/drivers-of-change.html" class="dropdown-toggle" role="button">Drivers of change</a></li><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/our-goals.html" class="dropdown-toggle" role="button">Our goals</a></li><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/priorities.html" class="dropdown-toggle" role="button">Priorities</a></li><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/key-areas-of-work.html" class="dropdown-toggle" role="button">Key areas of work</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/strategy2030/measuring-success.html" class="dropdown-toggle" role="button">Measuring success</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/news.html" class="dropdown-toggle" role="button">News</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/events.html" class="dropdown-toggle" role="button">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html" class="dropdown-toggle" role="button">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/developing-standards.html" class="dropdown-toggle" role="button">Taking part</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/who-develops-standards.html" class="dropdown-toggle" role="button">Who develops standards</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/technical-committees.html" class="dropdown-toggle" role="button">Technical Committees</a></li><li role="none" class="noChildren"><a role="menuitem" href="/other-bodies-developing-standards.html" class="dropdown-toggle" role="button">Other bodies</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/organizations-in-cooperation-with-iso.html" class="dropdown-toggle" role="button">Organizations in cooperation</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html" class="dropdown-toggle" role="button">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html" class="dropdown-toggle" role="button">Get involved</a></li><li role="none" class="noChildren"><a role="menuitem" href="/ClimateAction.html" class="dropdown-toggle" role="button">Climate action kit</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown inPath lastInLevel"><a role="menuitem" href="/store.html" class="dropdown-toggle" role="button">Store</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html"  class="dropdown-toggle" role="button">Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html" class="dropdown-toggle" role="button">Publications and products</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="https://www.iso.org/obp/ui/#account/products"  target="_blank" class="dropdown-toggle" role="button">My account</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>

          <div class="container offcanvas-rigid">
            <a class="logo isologo" href="/home.html" title="International Organization for Standardization" alt="ISO logo"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.7/img/iso/iso-logo-print.gif" alt="ISO logo for print"/></div>

            <ul id="utilityNav" aria-label="Utilities Navigation" class="nav navbar-nav navbar-right">
              <li class="nav-glyphicon nav-search" id="nav-search">
                <form class="expandable isosearch" role="search">
                  <span class="hidden" data-urlbase="/cms/render/live/en"></span>
                  <span class="hidden" data-searchpagepath="/sites/isoorg/search"></span>
                  <label id="input-search" class="control-label hidden-xs" for="input-search">Search</label>
                  <input type="search" placeholder="" aria-labelledby="input-search">
                  <button class="glyphicon glyphicon-search" type="submit" aria-labelledby="input-search"></button>
                </form>
              </li>
              <li class="nav-glyphicon">
                <a class="shopping-cart-link" href="/webstore/shoppingbasket?memberId=ISO&guilang=en" title="Shopping cart" aria-label="Shopping cart">
                  <span class="glyphicon glyphicon-shopping-cart" id="shoppingItems"></span>
                </a>
              </li>
              

<li class="dropdown" id="lang-switcher">
  <a class="dropdown-toggle" data-toggle="dropdown" href="#">EN <span class="caret"></span></a>
  <ul class="dropdown-menu">
    <li><a href="/fr/standard/76389.html">français</a></li><li><a href="/ru/standard/76389.html">русский</a></li>
  </ul>
</li><div class="clear"></div>
            </ul>
            <!-- TOP LEVEL1 NAVIGATION -->
            <nav role="navigation" aria-label="Main Navigation" class="sidenav" id="mainNav"><ul role="menubar" class="nav navbar-nav navbar-right affix-topnav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/about-us.html">About us</a></li><li role="none" class="noChildren"><a role="menuitem" href="/news.html">News</a></li><li role="none" class="noChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a></li><li role="none" class="noChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
        </div>
        <div id="search-curtain"></div>
      </div>

      

    </header>
    <!-- MAIN CONTENT -->
    <main role="main" id="content" class="acer" aria-label="Content" tabindex="-1">
      





<span class="hidden" id="indexReference" data-index="76389 - ISO 683-3:2019 - Heat-treatable steels, alloy steels and free-cutting steels — Part 3: Case-hardening steels"></span>

  <span class="hidden" id="itemReference">ISO 683-3:2019</span>

<section itemscope itemtype="https://schema.org/Product" class="section-navigation">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <div class="hidden" itemprop="category">w</div>
        <div class="hidden" itemprop="productID" id="csNumber">76389</div>
        <div class="hidden" itemprop="brand" itemscope itemtype="https://schema.org/Organization">
          <div itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
            <meta itemprop="url" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif"/>
            <meta itemprop="width" content="283">
            <meta itemprop="height" content="261">
          </div>
          <meta itemprop="name" content="ISO - International Organization for Standardization">
        </div>

        <nav role="navigation" aria-label="Children Navigation" class="heading-condensed nav-relatives">

  
  <div class="section-head wrapped-danger wrapped-h1"><span class="icon "></span><a target="" href="/standards-catalogue/browse-by-ics.html"title="Browse the full collection of ISO standards and find the ones that apply to your sector.">ICS</a> >&nbsp;<a href="/en/ics/77.html">77</a> >&nbsp;<a href="/en/ics/77.140.html">77.140</a> >&nbsp;<a href="/en/ics/77.140.10.html">77.140.10</a></div>
  

  <h1>ISO 683-3:2019</h1>
  <h2 class="no-uppercase">Heat-treatable steels, alloy steels and free-cutting steels — Part 3: Case-hardening steels</h2>
</nav>
      </div>
    </div>
  </div>
</section>


  <section id="revised-by" class="bg-help section-sm">
    <div class="container">
      <div class="row">
        <div class="col-md-12">
          <h3 role="alert" class="no-margin">
            This standard has been revised by
              <a href="/standard/78216.html">ISO 683-3:2022</a>
          </h3>
        </div>
      </div>
    </div>
  </section>

<section id="product-details">
  <div class="container">
    <div class="row">
      <div class="col-md-7">
        
          <h3>Abstract&nbsp;</h3>
          <div itemprop="description">
            <p><p>This document specifies the technical delivery requirements for</p>
<p>—          semi-finished products, hot formed, e.g. blooms, billets, slabs (see NOTE 1),</p>
<p>—          bars (see NOTE 1),</p>
<p>—          wire rod,</p>
<p>—          finished flat products, and</p>
<p>—          hammer or drop forgings (see NOTE 1)</p>
<p>manufactured from the case-hardening non-alloy or alloy steels listed in Table 3 and supplied in one of the heat-treatment conditions given for the different types of products in Table 1 and in one of the surface conditions given in Table 2.</p>
<p>The steels are, in general, intended for the manufacture of case-hardened machine parts.</p>
<p>NOTE 1    Hammer-forged semi-finished products (blooms, billets, slabs, etc.), seamless rolled rings and hammer-forged bars are covered under semi-finished products or bars and not under the term "hammer and drop forgings".</p>
<p>NOTE 2    For International Standards relating to steels complying with the requirements for the chemical composition in Table 3, however, supplied in other product forms or treatment conditions than given above or intended for special applications, and for other related International Standards, see the Bibliography.</p>
<p>In special cases, variations in these technical delivery requirements or additions to them can form the subject of an agreement at the time of enquiry and order (see 5.2 and Annex A).</p>
<p>In addition to this document, the general technical delivery requirements of ISO 404 are applicable.</p></p>
          </div>
          <br/>
        <h3>
  General information
  <sup><a href="/contents/data/standard/07/63/76389.detail.rss" class="ss-icon ss-social-circle text-warning text-sm" data-toggle="iso-tooltip" data-original-title="Subscribe&nbsp;to&nbsp;updates">&#xE310;</a></sup>
  
</h3>


<ul class="refine">
  <li>
    <div class="row">
      <div class="col-sm-6">
        

          <strong>Status&nbsp;:&nbsp;&nbsp;</strong><span><span class="glyphicon glyphicon-ban-circle" title="Withdrawn"></span>Withdrawn</span>
        
      </div>
      <div class="col-sm-6">
        
          <strong>Publication date&nbsp;: </strong><span itemprop="releaseDate">2019-01</span>
        
      </div>
    </div>
  </li>
  <li>
    <div class="row">
      <div class="col-sm-6">
        
          <strong>Edition&nbsp;:</strong> 3
      </div>
      <div class="col-sm-6">
        
          <strong>Number of pages&nbsp;:</strong> 36
      </div>
    </div>
  </li>
  
    <li>
      <div class="clearfix">
        <div class="entry-label">Technical Committee</div> :
        <div class="entry-name entry-block">
          <a href="/committee/46358.html">ISO/TC 17/SC 4</a>
        </div>
        <div class="entry-title">Heat treatable and alloy steels</div>
      </div>
    </li>
  
  <li>
    <dl class="dl-inline no-bottom-margin">
      <dt class="entry-label entry-block"><strong>ICS : </strong></dt>
      
        <dd>
          <div class="entry-name entry-block">
            <a href="/ics/77.140.10.html">
                77.140.10
            </a>
          </div>
          <div class="entry-title">Heat-treatable steels</div>
        </dd>
      
        <dd>
          <div class="entry-name entry-block">
            <a href="/ics/77.140.20.html">
                77.140.20
            </a>
          </div>
          <div class="entry-title">Stainless steels</div>
        </dd>
      
    </dl>
  </li>
</ul>

      </div>

      <div class="col-md-4 col-md-offset-1">
        

      </div>
    </div>
  </div>
</section>


<section id="lifecycle">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <h3>Life cycle</h3>
        <br/>
        <div class="lifecycle">
          <ul class="steps">
            
              <li class="time-step">
                <h4 class="text-help">Previously</h4>
                
                <div class="step step-muted">
                  
                  <div class="step-item">
                    
                    <div class="section-head">Withdrawn</div>
                    <h5><a href="/standard/70644.html">ISO 683-3:2016</a></h5>
                  </div>
                
                </div>
              </li>
            
            <li class="time-step">
              <h4 class="text-help">Now</h4>
              
                  <div class="step step-help active">
                    <div class="section-head">Withdrawn</div>
                    
              <h5>ISO 683-3:2019</h5>
                  
              <a data-toggle="collapse" role="button" aria-expanded="false" data-target="#stages" class="dropdown-toggle current-stage text-sm">Stage: <strong>95.99</strong><span class="caret"></span></a>
            </div>
              <ul class="nav navbar-nav stages collapse" id="stages">
                

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>00</strong></span>
                        <div class="stage-title">Preliminary</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>10</strong></span>
                        <div class="stage-title">Proposal</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>20</strong></span>
                        <div class="stage-title">Preparatory</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>30</strong></span>
                        <div class="stage-title">Committee</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>40</strong></span>
                        <div class="stage-title">Enquiry</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#40_99">
                              <span class="stage-code">40.99</span>
                              <span class="stage-date">2018-06-22</span>
                              <div class="stage-title">
                                Full report circulated: DIS approved for registration as FDIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>50</strong></span>
                        <div class="stage-title">Approval</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#50_00">
                              <span class="stage-code">50.00</span>
                              <span class="stage-date">2018-07-10</span>
                              <div class="stage-title">
                                Final text received or FDIS registered for formal approval
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_20">
                              <span class="stage-code">50.20</span>
                              <span class="stage-date">2018-08-24</span>
                              <div class="stage-title">
                                Proof sent to secretariat or FDIS ballot initiated: 8 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_60">
                              <span class="stage-code">50.60</span>
                              <span class="stage-date">2018-11-17</span>
                              <div class="stage-title">
                                Close of voting. Proof returned by secretariat
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-success">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>60</strong></span>
                        <div class="stage-title">Publication</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#60_00">
                              <span class="stage-code">60.00</span>
                              <span class="stage-date">2018-11-17</span>
                              <div class="stage-title">
                                International Standard under publication
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#60_60">
                              <span class="stage-code">60.60</span>
                              <span class="stage-date">2019-01-15</span>
                              <div class="stage-title">
                                International Standard published
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-success">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>90</strong></span>
                        <div class="stage-title">Review</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#90_92">
                              <span class="stage-code">90.92</span>
                              <span class="stage-date">2019-02-27</span>
                              <div class="stage-title">
                                International Standard to be revised
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown bg-help active">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>95</strong></span>
                        <div class="stage-title">Withdrawal</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li class="active">
                            <a href="/stage-codes.html#95_99">
                              <span class="stage-code">95.99</span>
                              <span class="stage-date">2022-01-21</span>
                              <div class="stage-title">
                                Withdrawal of International Standard
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  
              </ul>

                  
            </li>
            
              <li class="time-step">

              
                  <h4 class="text-help">Revised by</h4>
                  <div class="step step-success">
                
                  <div class="step-item">
                    <div class="section-head">Published</div>
                    <h5><a href="/standard/78216.html">ISO 683-3:2022</a></h5>
                  </div>
                </div>
              </li>
            
          </ul>
        </div>
      </div>
    </div>
  </div>
</section>
<section class="bg-info" id="contact">
  <div class="container">
    <div class="row">
      <div class="col-md-4">
        <h4>Got a question?</h4>

<p>Check out our <a href="/frequently-asked-questions-faqs.html" title="Frequently Asked Questions (FAQs)">FAQs</a></p>
      </div>
      <div class="col-md-4">
        <div class="vcard contact no-figure clearfix" itemscope="" itemtype="http://schema.org/Person">
<div class="content-box no-image">
<div class="fn n"><span class="given-name" itemprop="givenName">Customer care</span></div>

<div class="tel" itemprop="telephone">+41 22 749 08 88</div>

<div class="email" itemprop="email"><a href="mailto:customerservice@iso.org">customerservice@iso.org</a></div>

<hr />
<div class="note">
<p class="small">Opening hours:<br />
Monday to Friday - 09:00-12:00, 14:00-17:00 (UTC+1)</p>
</div>
</div>
</div>
      </div>
      <div class="col-md-4">
        <div class="well text-center clearfix">
  <h4>Keep up to date with ISO</h4>

<p>Sign up to our newsletter for the latest news, views and product information.</p><div><a class="btn btn-primary" data-fancybox="" data-type="iframe" href="https://confirmsubscription.com/h/d/3412DA7993AC3B7C">Subscribe</a></div>
<style type="text/css">.fancybox-slide--iframe .fancybox-content {
 width  : 500px;
 height : 600px;
 max-width  : 80%;
 max-height : 80%;
 margin: 0;
}
.fancybox-slide--iframe .fancybox-content .l-page-container {
padding-top: 1.5rem !important;
}
</style>
</div>
      </div>
    </div>
  </div>
</section><div class="clear"></div>
      <div class="nav-breadcrumb print-footer bg-darkgray">
        <div class="container">
          <div class="row">
            <div class="col-sm-8 small">
              <!-- BREADCRUMB -->
              <ol class="breadcrumb">
    
      <li><a href="/home.html" title="Home page"><span class="glyphicon glyphicon-home" aria-hidden="true"></span></a></li>
    
        <li>
          
              <a href="/store.html">Store</a>
            
        </li>
      
        <li>
          
<a href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a>

        </li>
      
        <li>
          
              <a href="/standards-catalogue/browse-by-ics.html">ICS</a>
            
        </li>
      <li><a href="/en/ics/77.html">77</a></li>
    
      <li><a href="/en/ics/77.140.html">77.140</a></li>
    
      <li><a href="/en/ics/77.140.10.html">77.140.10</a></li>
    <li>ISO 683-3:2019</li>
  </ol><div class="clear"></div>
            </div>
            <div class="col-sm-4 hidden-print text-right small">
              <a role="button" class="accordion-toggle collapsed" data-toggle="collapse" href="#collapseSitemap" target="_self" aria-expanded="false"
                 aria-controls="collapseSitemap">Sitemap</a>
            </div>
          </div>

          <div class="collapse border-top" id="collapseSitemap">
            <div class="row">
              <!-- SITEMAP -->
              <nav role="navigation" aria-label="Sitemap" class="sitemap-footer clearfix small" id="nav-sitemap"><ul role="menubar" class="nav-level1 list-inline-5 clearfix"><li role="none" class="hasChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/benefits-of-standards.html">Benefits</a></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html">Popular standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/conformity-assessment.html">Certification & conformity</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/about-us.html">About us</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/what-we-do.html">What we do</a></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html">Members</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/strategy2030.html">Strategy</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/news.html">News</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren"><a role="menuitem" href="/events.html">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/who-develops-standards.html">Who develops standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html">Get involved</a></li><li role="none" class="noChildren"><a role="menuitem" href="/ClimateAction.html">Climate action kit</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html">Publications and products</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>
            </div>
          </div>
        </div>
      </div>

      
      <footer role="contentinfo" aria-label="Footer" class="footer-iso footer-dark bg-darkergray">
        <div class="container">
          <div class="footer-links center-block">
            <!-- FOOTER LINKS -->
            <nav role="navigation" aria-label="Inline Navigation"  ><ul role="menubar" class="list-inline clearfix nav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-name-and-logo.html">ISO name and logo</a></li><li role="none" class="noChildren"><a role="menuitem" href="/privacy-and-copyright.html">Privacy and copyright</a></li><li role="none" class="noChildren"><a role="menuitem" href="/working-with-iso.html" >Jobs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/frequently-asked-questions-faqs.html">FAQs</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/contact-iso.html">Contact ISO</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
          <div class="footer-social ss-icon clearfix">
            <ul itemscope itemtype="https://schema.org/Organization">
              <link itemprop="url" href="https://www.iso.org/">
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.linkedin.com/company/isostandards" title="Linkedin"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://twitter.com/isostandards" title="Twitter"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.facebook.com/isostandards" title="Facebook"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.youtube.com/user/PlanetISO" title="YouTube"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.instagram.com/isostandards" title="Instagram"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.flickr.com/photos/isostandards" title="Flickr"></a></li>
            </ul>
          </div>
          <p class="lead">Great things happen when the world agrees</p>
          <div class="row">
            <div class="col-md-8 col-md-offset-2 pull-left">
              <p class="text-xs">We are committed to ensuring that our website is accessible to everyone. If you have any questions or suggestions regarding the accessibility of this site, please <a href="mailto:webmaster@iso.org?subject=Accessibility" style="white-space: nowrap">contact us</a>.</p>
              <p class="text-sm"><a href="#copyright" target="_self" data-toggle="collapse" aria-expanded="false" aria-controls="copyright">© All Rights Reserved</a> <span id="copyright" class="collapse">All ISO publications and materials are protected by copyright and are subject to the user’s acceptance of ISO’s conditions of copyright. Any use, including reproduction requires our written permission. All copyright requests should be addressed to <a href="mailto:copyright@iso.org">copyright@iso.org</a>.</span></p>
            </div>
          </div>
        </div>
        <div class="topbar">
          <div class="topbar-content">
            <a class="logo isologo logo-xs theme-red poweredby page-scroll logo-scrollTop" href="#page-top" title="Scroll to top"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.7/img/iso/iso-logo-print.gif" alt="ISO logo for print" /></div>
            <div class="poweredby-txt">Powered by</div>
          </div>
        </div>
        <div class="rubber"></div>
      </footer>

    </main>

    


  </body>
</html>
253
+ http_version:
254
+ recorded_at: Thu, 24 Feb 2022 13:51:41 GMT
255
+ - request:
256
+ method: get
257
+ uri: https://www.iso.org/standard/75281.html
258
+ body:
259
+ encoding: US-ASCII
260
+ string: ''
261
+ headers:
262
+ Accept-Encoding:
263
+ - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
264
+ Accept:
265
+ - "*/*"
266
+ User-Agent:
267
+ - Ruby
268
+ Host:
269
+ - www.iso.org
270
+ response:
271
+ status:
272
+ code: 200
273
+ message: ''
274
+ headers:
275
+ Expires:
276
+ - Wed, 09 May 1979 05:30:00 GMT
277
+ Cache-Control:
278
+ - no-cache, no-store, must-revalidate, proxy-revalidate, max-age=0
279
+ Pragma:
280
+ - no-cache
281
+ Set-Cookie:
282
+ - BIGipServerpool_prod_iso_www-jahia=713576842.36895.0000; path=/; Httponly;
283
+ Secure
284
+ - JSESSIONID=09D22A3D2B07B09F7E9FD88531316F4A; Path=/; Secure; HttpOnly
285
+ Vary:
286
+ - accept-encoding
287
+ Content-Type:
288
+ - text/html;charset=UTF-8
289
+ Transfer-Encoding:
290
+ - chunked
291
+ Date:
292
+ - Thu, 24 Feb 2022 13:51:40 GMT
293
+ Strict-Transport-Security:
294
+ - max-age=31536000; includeSubDomains
295
+ body:
296
+ encoding: ASCII-8BIT
297
+ string: !binary |-
298
+ <!DOCTYPE html>


<html lang="en">
  <head>
    
    <script>
      dataLayer = [{
        'pageType': 'its:standard',
        'pageLanguage': 'en'
      }];
    </script>

    <!-- Google Tag Manager -->
    <script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
        new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
      j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
      'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
    })(window,document,'script','dataLayer','GTM-TFGKQQB');</script>
    <!-- End Google Tag Manager -->

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <title>ISO - ISO/IEC 27005:2018 - Information technology — Security techniques — Information security risk management</title>

    
      <!--
      <link rel="preconnect" href="https://cdn.iso.org/" crossorigin />
      <link rel="preload" as="script" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.js" crossorigin />
      <link rel="preload" as="style" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.css" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/bootstrap/3.3.2/glyphicons-halflings-regular.woff2" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Bold.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-Normal.woff" crossorigin />
      <link rel="preload" as="font" href="https://cdn.iso.org/resources/fonts/metawebpro/7.504/MetaWebPro-NormalIta.woff" crossorigin />
      -->

    

    <link rel="canonical" href="https://www.iso.org/standard/75281.html" />

    <!-- start favicons -->
    <link rel="apple-touch-icon-precomposed" href="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/apple-touch-icon-152x152-precomposed.png">
    <link rel="shortcut icon" href="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/favicon.ico">
    <meta name="msapplication-TileColor" content="#eee">
    <meta name="msapplication-TileImage" content="https://cdn.iso.org/resources/wood/3.3.7/img/iso/favicon/red/mstile-144x144.png">
    <!-- end favicons -->

    
    <meta name="theme-color" content="#333">

  
<script type="text/javascript">
var contextJsParameters={contextPath:"",lang:"en",uilang:"en",siteUuid:"439146f8-677e-4dde-b6c6-b692b7534f52",wcag:false,ckeCfg:""}; var CKEDITOR_BASEPATH="/modules/ckeditor/javascript/"; var scayt_custom_params=new Array(); scayt_custom_params['sLang']='en_US';
</script>
<link id="staticAssetCSS0" rel="stylesheet" href="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.css" media="screen,print,handheld" type="text/css"/>
<link id="staticAssetCSS1" rel="stylesheet" href="/modules/assets/css/languageSwitchingLinks.css?1532003505766" media="screen" type="text/css"/>
<link id="staticAssetCSS2" rel="stylesheet" href="/modules/iso-jahia-service-module/css/catalogue.css?1642771880426" media="screen" type="text/css"/>
<script id="staticAssetJavascript0" type="text/javascript" src="https://cdn.iso.org/resources/wood/3.3.7/wood.full.min.js"  ></script>
<script id="staticAssetJavascript1" type="text/javascript" src="/modules/iso-jahia-service-module/javascript/catalogue.js?1642771880426"  ></script>
<script id="staticAssetJavascript2" type="text/javascript" src="/modules/isoorg-template/javascript/custom.js?1635768247679"  ></script>

    <meta name="category" content="p" />
  
    <meta name="pubdate" content="20200127" />
  

  <!-- Twitter Card data -->
  <meta name="twitter:site" content="@isostandards" />

  <!-- Open Graph data -->
  <meta property="og:site_name" content="ISO" />
  <meta property="og:url" content="https://www.iso.org/cms/render/live/en/sites/isoorg/contents/data/standard/07/52/75281.html" />
  
    <meta property="og:type" content="website" />
  
    <!-- Thumbnail image (for twitter and Open Graph) -->
    <meta name="thumbnail" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta name="twitter:card" content="summary" />
    <meta name="twitter:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif" />
    <meta property="og:image:alt" content="ISO logo" />
  
    <!-- Title (for twitter and Open Graph) -->
    <meta name="twitter:title" content="ISO/IEC 27005:2018" />
    <meta property="og:title" content="ISO/IEC 27005:2018" />
  
    <!-- Description (for google, twitter and Open Graph) -->
    <meta name="twitter:description" content="Information technology — Security techniques — Information security risk management" />
    <meta property="og:description" content="Information technology — Security techniques — Information security risk management" />
    <meta name="description" content="Information technology — Security techniques — Information security risk management" />
  

  <!-- Facebook admins : Lionel,Maria -->
  <meta property="fb:admins" content="100001116079676,100001440003305" />

  

</head>
  <body class="theme-red" id="offcanvas-content">
    <!-- Google Tag Manager (noscript) -->
    <noscript aria-hidden="true"><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TFGKQQB" height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
    <!-- End Google Tag Manager (noscript) -->
    <a class="skip-navigation btn btn-info sr-only sr-only-focusable" href="#content">Skip to main content</a>
    <!-- Header ISO.ORG -->
    <header role="banner" aria-label="Header" class="theme-red header-acer " id="page-top">
      <div class="container">
        <div class="navbar navbar-inverse navbar-fixed-top navbar-default navbar-acer theme-red" data-spy="affix" data-offset-top="200">
          <button role="button" id="offcanvas-btn" class="btn btn-transparent pull-right" data-toggle="open-offcanvas"><span class="glyphicon glyphicon-menu-hamburger"></span><span class="hidden-xxs"> Menu</span></button>

          <!-- SIDE NAVIGATION -->
          <nav role="navigation" aria-label="Side Navigation" class="sidenav" id="offcanvas-panel"><ul role="menubar" class="nav navbar-nav nav-level1"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/standards.html" class="dropdown-toggle" role="button">Standards</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/benefits-of-standards.html" class="dropdown-toggle" role="button">Benefits</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-and-smes.html" class="dropdown-toggle" role="button">SMEs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-consumers.html" class="dropdown-toggle" role="button">Consumers</a></li><li role="none" class="noChildren"><a role="menuitem" href="/iso-and-policy-makers.html" class="dropdown-toggle" role="button">ISO and policy makers</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/standards-in-action.html" class="dropdown-toggle" role="button">Standards in action</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html" class="dropdown-toggle" role="button">Popular standards</a></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/conformity-assessment.html" class="dropdown-toggle" role="button">Certification & conformity</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/certification.html" class="dropdown-toggle" role="button">Certification</a></li><li role="none" class="noChildren"><a role="menuitem" href="/casco.html" class="dropdown-toggle" role="button">CASCO</a></li><li role="none" class="noChildren"><a role="menuitem" href="/the-iso-survey.html" class="dropdown-toggle" role="button">The ISO Survey</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources-for-conformity-assessment.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html" class="dropdown-toggle" role="button">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/about-us.html" class="dropdown-toggle" role="button">About us</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/what-we-do.html" class="dropdown-toggle" role="button">What we do</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/developing-standards.html"  class="dropdown-toggle" role="button">Developing standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/research-and-education.html" class="dropdown-toggle" role="button">Research</a></li><li role="none" class="noChildren"><a role="menuitem" href="/capacity-building.html" class="dropdown-toggle" role="button">Capacity building</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/education-about-standards.html" class="dropdown-toggle" role="button">Education about standards</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html" class="dropdown-toggle" role="button">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html" class="dropdown-toggle" role="button">Members</a></li><li role="none" class="noChildren"><a role="menuitem" href="/announcements.html" class="dropdown-toggle" role="button">Announcements</a></li><li role="none" class="hasChildren dropdown lastInLevel"><a role="menuitem" href="/strategy2030.html" class="dropdown-toggle" role="button">Strategy</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/drivers-of-change.html" class="dropdown-toggle" role="button">Drivers of change</a></li><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/our-goals.html" class="dropdown-toggle" role="button">Our goals</a></li><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/priorities.html" class="dropdown-toggle" role="button">Priorities</a></li><li role="none" class="noChildren"><a role="menuitem" href="/strategy2030/key-areas-of-work.html" class="dropdown-toggle" role="button">Key areas of work</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/strategy2030/measuring-success.html" class="dropdown-toggle" role="button">Measuring success</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/news.html" class="dropdown-toggle" role="button">News</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren"><a role="menuitem" href="/events.html" class="dropdown-toggle" role="button">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html" class="dropdown-toggle" role="button">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown"><a role="menuitem" href="/developing-standards.html" class="dropdown-toggle" role="button">Taking part</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="hasChildren dropdown firstInLevel"><a role="menuitem" href="/who-develops-standards.html" class="dropdown-toggle" role="button">Who develops standards</a><ul role="menu" class="nav navbar-nav nav-level3 dropdown-menu"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/technical-committees.html" class="dropdown-toggle" role="button">Technical Committees</a></li><li role="none" class="noChildren"><a role="menuitem" href="/other-bodies-developing-standards.html" class="dropdown-toggle" role="button">Other bodies</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/organizations-in-cooperation-with-iso.html" class="dropdown-toggle" role="button">Organizations in cooperation</a></li></ul><!-- close of ul level --></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html" class="dropdown-toggle" role="button">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html" class="dropdown-toggle" role="button">Get involved</a></li><li role="none" class="noChildren"><a role="menuitem" href="/ClimateAction.html" class="dropdown-toggle" role="button">Climate action kit</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html" class="dropdown-toggle" role="button">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren dropdown inPath lastInLevel"><a role="menuitem" href="/store.html" class="dropdown-toggle" role="button">Store</a><ul role="menu" class="nav navbar-nav nav-level2 dropdown-menu"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html"  class="dropdown-toggle" role="button">Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html" class="dropdown-toggle" role="button">Publications and products</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="https://www.iso.org/obp/ui/#account/products"  target="_blank" class="dropdown-toggle" role="button">My account</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>

          <div class="container offcanvas-rigid">
            <a class="logo isologo" href="/home.html" title="International Organization for Standardization" alt="ISO logo"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.7/img/iso/iso-logo-print.gif" alt="ISO logo for print"/></div>

            <ul id="utilityNav" aria-label="Utilities Navigation" class="nav navbar-nav navbar-right">
              <li class="nav-glyphicon nav-search" id="nav-search">
                <form class="expandable isosearch" role="search">
                  <span class="hidden" data-urlbase="/cms/render/live/en"></span>
                  <span class="hidden" data-searchpagepath="/sites/isoorg/search"></span>
                  <label id="input-search" class="control-label hidden-xs" for="input-search">Search</label>
                  <input type="search" placeholder="" aria-labelledby="input-search">
                  <button class="glyphicon glyphicon-search" type="submit" aria-labelledby="input-search"></button>
                </form>
              </li>
              <li class="nav-glyphicon">
                <a class="shopping-cart-link" href="/webstore/shoppingbasket?memberId=ISO&guilang=en" title="Shopping cart" aria-label="Shopping cart">
                  <span class="glyphicon glyphicon-shopping-cart" id="shoppingItems"></span>
                </a>
              </li>
              

<li class="dropdown" id="lang-switcher">
  <a class="dropdown-toggle" data-toggle="dropdown" href="#">EN <span class="caret"></span></a>
  <ul class="dropdown-menu">
    <li><a href="/fr/standard/75281.html">français</a></li><li><a href="/ru/standard/75281.html">русский</a></li>
  </ul>
</li><div class="clear"></div>
            </ul>
            <!-- TOP LEVEL1 NAVIGATION -->
            <nav role="navigation" aria-label="Main Navigation" class="sidenav" id="mainNav"><ul role="menubar" class="nav navbar-nav navbar-right affix-topnav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/about-us.html">About us</a></li><li role="none" class="noChildren"><a role="menuitem" href="/news.html">News</a></li><li role="none" class="noChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a></li><li role="none" class="noChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
        </div>
        <div id="search-curtain"></div>
      </div>

      

    </header>
    <!-- MAIN CONTENT -->
    <main role="main" id="content" class="acer" aria-label="Content" tabindex="-1">
      





<span class="hidden" id="indexReference" data-index="75281 - ISO/IEC 27005:2018 - Information technology — Security techniques — Information security risk management"></span>

  <span class="hidden" id="itemReference">ISO/IEC 27005:2018</span>

<section itemscope itemtype="https://schema.org/Product" class="section-navigation">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <div class="hidden" itemprop="category">p</div>
        <div class="hidden" itemprop="productID" id="csNumber">75281</div>
        <div class="hidden" itemprop="brand" itemscope itemtype="https://schema.org/Organization">
          <div itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
            <meta itemprop="url" content="https://cdn.iso.org/resources/wood/3.3.3/img/iso/iso-logo-print.gif"/>
            <meta itemprop="width" content="283">
            <meta itemprop="height" content="261">
          </div>
          <meta itemprop="name" content="ISO - International Organization for Standardization">
        </div>

        <nav role="navigation" aria-label="Children Navigation" class="heading-condensed nav-relatives">

  
  <div class="section-head wrapped-danger wrapped-h1"><span class="icon "></span><a target="" href="/standards-catalogue/browse-by-ics.html"title="Browse the full collection of ISO standards and find the ones that apply to your sector.">ICS</a> >&nbsp;<a href="/en/ics/35.html">35</a> >&nbsp;<a href="/en/ics/35.030.html">35.030</a></div>
  

  <h1>ISO/IEC 27005:2018</h1>
  <h2 class="no-uppercase">Information technology — Security techniques — Information security risk management</h2>
</nav>
      </div>
    </div>
  </div>
</section>


  <section class="section-sm bg-primary visible-xs-block">
    <div class="container">
      <div class="row">
        <div class="col-md-12">
          <h4 class="text-center">
            <a href="#store-box" class="page-scroll">
              Buy this standard
            </a>
          </h4>
        </div>
      </div>
    </div>
  </section>

<section id="product-details">
  <div class="container">
    <div class="row">
      <div class="col-md-7">
        
          <h3>Abstract&nbsp;<a class="btn btn-primary btn-outline" id="obp-preview" target="_blank" href="https://www.iso.org/obp/ui/#!iso:std:75281:en">Preview</a></h3>
          <div itemprop="description">
            <p><p>This document provides guidelines for information security risk management.</p>
<p>This document supports the general concepts specified in ISO/IEC 27001 and is designed to assist the satisfactory implementation of information security based on a risk management approach.</p>
<p>Knowledge of the concepts, models, processes and terminologies described in ISO/IEC 27001 and ISO/IEC 27002 is important for a complete understanding of this document.</p>
<p>This document is applicable to all types of organizations (e.g. commercial enterprises, government agencies, non-profit organizations) which intend to manage risks that can compromise the organization's information security.</p></p>
          </div>
          <br/>
        <h3>
  General information
  <sup><a href="/contents/data/standard/07/52/75281.detail.rss" class="ss-icon ss-social-circle text-warning text-sm" data-toggle="iso-tooltip" data-original-title="Subscribe&nbsp;to&nbsp;updates">&#xE310;</a></sup>
  
</h3>


<ul class="refine">
  <li>
    <div class="row">
      <div class="col-sm-6">
        

          <strong>Status&nbsp;:&nbsp;&nbsp;</strong><span><span class="glyphicon glyphicon-ok-circle" title="Published"></span>Published</span>
        
      </div>
      <div class="col-sm-6">
        
          <strong>Publication date&nbsp;: </strong><span itemprop="releaseDate">2018-07</span>
        
      </div>
    </div>
  </li>
  <li>
    <div class="row">
      <div class="col-sm-6">
        
          <strong>Edition&nbsp;:</strong> 3
      </div>
      <div class="col-sm-6">
        
          <strong>Number of pages&nbsp;:</strong> 56
      </div>
    </div>
  </li>
  
    <li>
      <div class="clearfix">
        <div class="entry-label">Technical Committee</div> :
        <div class="entry-name entry-block">
          <a href="/committee/45306.html">ISO/IEC JTC 1/SC 27</a>
        </div>
        <div class="entry-title">Information security, cybersecurity and privacy protection</div>
      </div>
    </li>
  
  <li>
    <dl class="dl-inline no-bottom-margin">
      <dt class="entry-label entry-block"><strong>ICS : </strong></dt>
      
        <dd>
          <div class="entry-name entry-block">
            <a href="/ics/35.030.html">
                35.030
            </a>
          </div>
          <div class="entry-title">IT Security</div>
        </dd>
      
    </dl>
  </li>
</ul>

      </div>

      <div class="col-md-4 col-md-offset-1">
        
  <div class="well shadow-light store-box product-box top-md-push-3" id="store-box">
    <div class="box-text">
      <h3>Buy&nbsp;this standard</h3>
      <div class="fit-to-box">
        <span class="language-path hidden">en</span>
        <table class="table orderProduct">
          <thead>
          <tr>
            <th></th>
            <th>Format</th>
            <th id="language">Language</th>
          </tr>
          </thead>
          <tbody>
          

            <tr class="active">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">1</span>
                <span class="price hidden">178</span>
                <span class="chooseFormat active"><span class="glyphicon glyphicon-ok"></span></span>
              </td>
              <td id="bkifmt_1" class="col-xs-10">
                PDF + ePub
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_1" aria-labelledby="language">
                  
                    <option value="01ub0000002864VAAQ~a05b0000005WV3eAAG~a0f0X00000XHFwiQAH~a0c0X00000HY1xiQAD" lang="en" selected>
                      English
                    </option>
                  
                    <option value="01ub0000002864VAAQ~a05b0000005WV3eAAG~a0f0X00000XHFvyQAH~a0c0X00000HY1wyQAD" lang="fr">
                      French
                    </option>
                  
                </select>
              </td>
            </tr>
          

            <tr class="">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">2</span>
                <span class="price hidden">214</span>
                <span class="chooseFormat"><span class="glyphicon glyphicon-ok hidden"></span></span>
              </td>
              <td id="bkifmt_2" class="col-xs-10">
                PDF + Redline
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_2" disabled aria-labelledby="language">
                  
                    <option value="01ub0000002864VAAQ~a05b0000007CTijAAG~a0f0X00000XHF8dQAH~a0c0X00000HY137QAD" lang="en" selected>
                      English
                    </option>
                  
                </select>
              </td>
            </tr>
          

            <tr class="">
              <td class="selection col-xs-1">
                <span class="type hidden">std</span>
                <span class="counter hidden">3</span>
                <span class="price hidden">178</span>
                <span class="chooseFormat"><span class="glyphicon glyphicon-ok hidden"></span></span>
              </td>
              <td id="bkifmt_3" class="col-xs-10">
                Paper
              </td>
              <td class="orderLanguage col-xs-1">
                <select id="bki_3" disabled aria-labelledby="language">
                  
                    <option value="01ub0000002864VAAQ~a05b0000005WV3jAAG~a0fb0000000eGWeAAM~a0c0X00000HY11bQAD" lang="en" selected>
                      English
                    </option>
                  
                    <option value="01ub0000002864VAAQ~a05b0000005WV3jAAG~a0fb0000000eGJ7AAM~a0c0X00000HY105QAD" lang="fr">
                      French
                    </option>
                  
                </select>
              </td>
            </tr>
          
          </tbody>
        </table>
      </div>
    </div>
    <div class="clearfix" itemprop="offers" itemscope itemtype="https://schema.org/Offer">
      <ul class="list-inline pull-right orderBasket" id="bkianchor_1">
        <li class="price order">
          <span class="currency" itemprop="priceCurrency">CHF</span><span class="amount" id="productPrice" itemprop="price">178</span>
        </li>
        <li>
          <button class="btn btn-primary" id="standard-buy" data-toggle="modal" data-target="#iso-optout" onclick="javascript:addToBasket('1', 'en', 'std')">
            <span class="glyphicon glyphicon-shopping-cart"></span>Buy
          </button>
        </li>
      </ul>
    </div>
  </div>

  <!-- START OF MODAL (Buy ISO.ORG with OPTOUT) -->
  <div class="modal fade" tabindex="-1" role="dialog" id="iso-optout">
    <div class="modal-dialog">
      <div class="modal-content">
        <div class="modal-body">
          <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          <div class="modal-body clearfix">
            <div id="modalOptOut"></div>
            <div id="modalNoOptOut"></div>
            <span id="proceedToCheckout" class="hidden" data-label="Proceed to checkout"></span>
            <span id="continueShopping" class="hidden" data-label="Add to basket and continue shopping"></span>
          </div>
        </div>
      </div>
    </div>
  </div>
  <!-- END OF MODAL -->


      </div>
    </div>
  </div>
</section>


<section id="lifecycle">
  <div class="container">
    <div class="row">
      <div class="col-md-12">
        <h3>Life cycle</h3>
        <br/>
        <div class="lifecycle">
          <ul class="steps">
            
              <li class="time-step">
                <h4 class="text-help">Previously</h4>
                
                <div class="step step-muted">
                  
                  <div class="step-item">
                    
                    <div class="section-head">Withdrawn</div>
                    <h5><a href="/standard/56742.html">ISO/IEC 27005:2011</a></h5>
                  </div>
                
                </div>
              </li>
            
            <li class="time-step">
              <h4 class="text-help">Now</h4>
              
                <div class="step step-success active">
                  <div class="section-head">Published</div>
                  
              <h5>ISO/IEC 27005:2018</h5>
                  <br/>A standard is reviewed every 5 years<br/>
              <a data-toggle="collapse" role="button" aria-expanded="false" data-target="#stages" class="dropdown-toggle current-stage text-sm">Stage: <strong>90.92</strong> (To be revised)<span class="caret"></span></a>
            </div>
              <ul class="nav navbar-nav stages collapse" id="stages">
                

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>00</strong></span>
                        <div class="stage-title">Preliminary</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>10</strong></span>
                        <div class="stage-title">Proposal</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>20</strong></span>
                        <div class="stage-title">Preparatory</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>30</strong></span>
                        <div class="stage-title">Committee</div>
                        
                      </a>

                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>40</strong></span>
                        <div class="stage-title">Enquiry</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#40_99">
                              <span class="stage-code">40.99</span>
                              <span class="stage-date">2018-01-05</span>
                              <div class="stage-title">
                                Full report circulated: DIS approved for registration as FDIS
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-info">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>50</strong></span>
                        <div class="stage-title">Approval</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#50_00">
                              <span class="stage-code">50.00</span>
                              <span class="stage-date">2018-01-29</span>
                              <div class="stage-title">
                                Final text received or FDIS registered for formal approval
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_20">
                              <span class="stage-code">50.20</span>
                              <span class="stage-date">2018-04-13</span>
                              <div class="stage-title">
                                Proof sent to secretariat or FDIS ballot initiated: 8 weeks
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#50_60">
                              <span class="stage-code">50.60</span>
                              <span class="stage-date">2018-06-10</span>
                              <div class="stage-title">
                                Close of voting. Proof returned by secretariat
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-success">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>60</strong></span>
                        <div class="stage-title">Publication</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#60_00">
                              <span class="stage-code">60.00</span>
                              <span class="stage-date">2018-06-10</span>
                              <div class="stage-title">
                                International Standard under publication
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#60_60">
                              <span class="stage-code">60.60</span>
                              <span class="stage-date">2018-07-09</span>
                              <div class="stage-title">
                                International Standard published
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown bg-success active">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>90</strong></span>
                        <div class="stage-title">Review</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li class="active">
                            <a href="/stage-codes.html#90_92">
                              <span class="stage-code">90.92</span>
                              <span class="stage-date">2020-01-27</span>
                              <div class="stage-title">
                                International Standard to be revised
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_93">
                              <span class="stage-code">90.93</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                International Standard confirmed
                              </div>
                            </a>
                          </li>
                          <li >
                            <a href="/stage-codes.html#90_99">
                              <span class="stage-code">90.99</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Withdrawal of International Standard proposed by TC or SC
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  

                    <li class="dropdown state-muted">
                      <a href="javascript:void(0)" class="dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="false">
                        
                        <span class="stage-code"><strong>95</strong></span>
                        <div class="stage-title">Withdrawal</div>
                        
                          <span class="caret"></span>
                        
                      </a>

                      
                        <ul class="dropdown-menu">
                            <li >
                            <a href="/stage-codes.html#95_99">
                              <span class="stage-code">95.99</span>
                              <span class="stage-date"></span>
                              <div class="stage-title">
                                Withdrawal of International Standard
                              </div>
                            </a>
                          </li>
                        </ul>
                      
                    </li>
                  
              </ul>

                  
            </li>
            
              <li class="time-step">

              
                  <h4 class="text-help">Will be replaced by</h4>
                  <div class="step step-info">
                
                  <div class="step-item">
                    <div class="section-head">Under development</div>
                    <h5><a href="/standard/80585.html">ISO/IEC DIS 27005</a></h5>
                  </div>
                </div>
              </li>
            
          </ul>
        </div>
      </div>
    </div>
  </div>
</section>

  <section id="related-news" class="bg-lightgray">
    <div class="container">
      <div class="row">
        <div class="col-md-12">
          <h3 class="page-header">This may also interest you</h3>
        </div>
      </div>
      <div class="row">
        <div class="col-md-7">
          <h4>News</h4>
          <div class="media-list media-300">
            <div class="media clearfix square">

  <div class="media-left">
    <figure class="">
      <a href="/news/ref2604.html"  title="Keeping an eye on information security" aria-label="Keeping an eye on information security">
            <img loading="lazy" src="/files/live/sites/isoorg/files/news/News_archive/2020/12/Ref2604/Ref2604.jpg/thumbnails/150x150" srcset="/files/live/sites/isoorg/files/news/News_archive/2020/12/Ref2604/Ref2604.jpg/thumbnails/150x150 150w, /files/live/sites/isoorg/files/news/News_archive/2020/12/Ref2604/Ref2604.jpg/thumbnails/300x300 300w" sizes="100px" class="media-object width-100 hover-zoom" alt="Hacker dressed in black and wearing a Guy Fawkes mask sits at a desk in a dark room, illuminated only up by the dim light of his laptop screen." />
          </a>
    </figure>
  </div>

  <div class="media-body">
  
    <div class="entry-header">
      
        <div class="entry-description small">
          
            <span class="time">
              <time class='updated' datetime='2020-12-16'>16 December 2020</time>
            </span>
          
        </div>
      
    </div>
  
    <div class="entry-content">
      
        <h6 class="entry-name entry-title">
          <a href="/news/ref2604.html" >Keeping an eye on information security</a>
        </h6>
      
        <div class="entry-summary">
          The standard for IS governance just updated.
        </div>
      
    </div>
    
  </div><!-- close of media-body-->
</div><!-- close of media--><div class="media clearfix square">

  <div class="media-left">
    <figure class="">
      <a href="/news/ref2360.html"  title="How to tackle today’s IT security risks" aria-label="How to tackle today’s IT security risks">
            <img loading="lazy" src="/files/live/sites/isoorg/files/news/News_archive/2019/01/Ref2360/Ref2360.jpg/thumbnails/150x150" srcset="/files/live/sites/isoorg/files/news/News_archive/2019/01/Ref2360/Ref2360.jpg/thumbnails/150x150 150w, /files/live/sites/isoorg/files/news/News_archive/2019/01/Ref2360/Ref2360.jpg/thumbnails/300x300 300w" sizes="100px" class="media-object width-100 hover-zoom" alt="" />
          </a>
    </figure>
  </div>

  <div class="media-body">
  
    <div class="entry-header">
      
        <div class="entry-description small">
          
            <span class="time">
              <time class='updated' datetime='2019-01-10'>10 January 2019</time>
            </span>
          
        </div>
      
    </div>
  
    <div class="entry-content">
      
        <h6 class="entry-name entry-title">
          <a href="/news/ref2360.html" >How to tackle today’s IT security risks</a>
        </h6>
      
        <div class="entry-summary">
          Industry experts estimate that annual losses from cybercrime could rise to USD 2 trillion by next year. With countless new targets added every day, especially mobile devices and connected “things”, a joined-up&nbsp;&#8230;
        </div>
      
    </div>
    
  </div><!-- close of media-body-->
</div><!-- close of media--><div class="media clearfix square">

  <div class="media-left">
    <figure class="">
      <a href="/news/ref2309.html"  title="Reducing the risks of information security breaches with ISO/IEC 27005" aria-label="Reducing the risks of information security breaches with ISO/IEC 27005">
            <img loading="lazy" src="/files/live/sites/isoorg/files/news/News_archive/2018/07/Ref2309/Ref2309.jpg/thumbnails/150x150" srcset="/files/live/sites/isoorg/files/news/News_archive/2018/07/Ref2309/Ref2309.jpg/thumbnails/150x150 150w, /files/live/sites/isoorg/files/news/News_archive/2018/07/Ref2309/Ref2309.jpg/thumbnails/300x300 300w" sizes="100px" class="media-object width-100 hover-zoom" alt="Fingerprint login access on a smartphone. " />
          </a>
    </figure>
  </div>

  <div class="media-body">
  
    <div class="entry-header">
      
        <div class="entry-description small">
          
            <span class="time">
              <time class='updated' datetime='2018-07-13'>13 July 2018</time>
            </span>
          
        </div>
      
    </div>
  
    <div class="entry-content">
      
        <h6 class="entry-name entry-title">
          <a href="/news/ref2309.html" >Reducing the risks of information security breaches with ISO/IEC 27005</a>
        </h6>
      
        <div class="entry-summary">
          In our hyper-connected, technology driven world, data breaches and cyber-attacks remain a significant threat to organizations, and a lack of awareness of the risks is often to blame. A newly revised standard&nbsp;&#8230;
        </div>
      
    </div>
    
  </div><!-- close of media-body-->
</div><!-- close of media-->
          </div>
        </div>
        <div class="col-md-4 col-md-offset-1">
          

        </div>
      </div>
    </div>
  </section>
<section class="bg-info" id="contact">
  <div class="container">
    <div class="row">
      <div class="col-md-4">
        <h4>Got a question?</h4>

<p>Check out our <a href="/frequently-asked-questions-faqs.html" title="Frequently Asked Questions (FAQs)">FAQs</a></p>
      </div>
      <div class="col-md-4">
        <div class="vcard contact no-figure clearfix" itemscope="" itemtype="http://schema.org/Person">
<div class="content-box no-image">
<div class="fn n"><span class="given-name" itemprop="givenName">Customer care</span></div>

<div class="tel" itemprop="telephone">+41 22 749 08 88</div>

<div class="email" itemprop="email"><a href="mailto:customerservice@iso.org">customerservice@iso.org</a></div>

<hr />
<div class="note">
<p class="small">Opening hours:<br />
Monday to Friday - 09:00-12:00, 14:00-17:00 (UTC+1)</p>
</div>
</div>
</div>
      </div>
      <div class="col-md-4">
        <div class="well text-center clearfix">
  <h4>Keep up to date with ISO</h4>

<p>Sign up to our newsletter for the latest news, views and product information.</p><div><a class="btn btn-primary" data-fancybox="" data-type="iframe" href="https://confirmsubscription.com/h/d/3412DA7993AC3B7C">Subscribe</a></div>
<style type="text/css">.fancybox-slide--iframe .fancybox-content {
 width  : 500px;
 height : 600px;
 max-width  : 80%;
 max-height : 80%;
 margin: 0;
}
.fancybox-slide--iframe .fancybox-content .l-page-container {
padding-top: 1.5rem !important;
}
</style>
</div>
      </div>
    </div>
  </div>
</section><div class="clear"></div>
      <div class="nav-breadcrumb print-footer bg-darkgray">
        <div class="container">
          <div class="row">
            <div class="col-sm-8 small">
              <!-- BREADCRUMB -->
              <ol class="breadcrumb">
    
      <li><a href="/home.html" title="Home page"><span class="glyphicon glyphicon-home" aria-hidden="true"></span></a></li>
    
        <li>
          
              <a href="/store.html">Store</a>
            
        </li>
      
        <li>
          
<a href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a>

        </li>
      
        <li>
          
              <a href="/standards-catalogue/browse-by-ics.html">ICS</a>
            
        </li>
      <li><a href="/en/ics/35.html">35</a></li>
    
      <li><a href="/en/ics/35.030.html">35.030</a></li>
    <li>ISO/IEC 27005:2018</li>
  </ol><div class="clear"></div>
            </div>
            <div class="col-sm-4 hidden-print text-right small">
              <a role="button" class="accordion-toggle collapsed" data-toggle="collapse" href="#collapseSitemap" target="_self" aria-expanded="false"
                 aria-controls="collapseSitemap">Sitemap</a>
            </div>
          </div>

          <div class="collapse border-top" id="collapseSitemap">
            <div class="row">
              <!-- SITEMAP -->
              <nav role="navigation" aria-label="Sitemap" class="sitemap-footer clearfix small" id="nav-sitemap"><ul role="menubar" class="nav-level1 list-inline-5 clearfix"><li role="none" class="hasChildren firstInLevel"><a role="menuitem" href="/standards.html">Standards</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/benefits-of-standards.html">Benefits</a></li><li role="none" class="noChildren"><a role="menuitem" href="/popular-standards.html">Popular standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/conformity-assessment.html">Certification & conformity</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/sdgs.html">SDGs</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/about-us.html">About us</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/what-we-do.html">What we do</a></li><li role="none" class="noChildren"><a role="menuitem" href="/structure.html">Structure</a></li><li role="none" class="noChildren"><a role="menuitem" href="/members.html">Members</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/strategy2030.html">Strategy</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/news.html">News</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren"><a role="menuitem" href="/events.html">Events</a></li><li role="none" class="noChildren"><a role="menuitem" href="/media-kit.html">Media kit</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren"><a role="menuitem" href="/developing-standards.html">Taking part</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/who-develops-standards.html">Who develops standards</a></li><li role="none" class="noChildren"><a role="menuitem" href="/deliverables-all.html">Deliverables</a></li><li role="none" class="noChildren"><a role="menuitem" href="/get-involved.html">Get involved</a></li><li role="none" class="noChildren"><a role="menuitem" href="/ClimateAction.html">Climate action kit</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/resources.html">Resources</a></li></ul><!-- close of ul level --></li><li role="none" class="hasChildren inPath lastInLevel"><a role="menuitem" href="/store.html">Store</a><ul role="menu" class="nav-level2 list-unstyled"><li role="none" class="noChildren inPath active firstInLevel"><a role="menuitem" href="/standards-catalogue/browse-by-ics.html" >Standards catalogue</a></li><li role="none" class="noChildren"><a role="menuitem" href="/publication-list.html">Publications and products</a></li></ul><!-- close of ul level --></li></ul><!-- close of ul level --></nav><div class="clear"></div>
            </div>
          </div>
        </div>
      </div>

      
      <footer role="contentinfo" aria-label="Footer" class="footer-iso footer-dark bg-darkergray">
        <div class="container">
          <div class="footer-links center-block">
            <!-- FOOTER LINKS -->
            <nav role="navigation" aria-label="Inline Navigation"  ><ul role="menubar" class="list-inline clearfix nav-level1"><li role="none" class="noChildren firstInLevel"><a role="menuitem" href="/iso-name-and-logo.html">ISO name and logo</a></li><li role="none" class="noChildren"><a role="menuitem" href="/privacy-and-copyright.html">Privacy and copyright</a></li><li role="none" class="noChildren"><a role="menuitem" href="/working-with-iso.html" >Jobs</a></li><li role="none" class="noChildren"><a role="menuitem" href="/frequently-asked-questions-faqs.html">FAQs</a></li><li role="none" class="noChildren lastInLevel"><a role="menuitem" href="/contact-iso.html">Contact ISO</a></li></ul><!-- close of ul level --></nav><div class="clear"></div>
          </div>
          <div class="footer-social ss-icon clearfix">
            <ul itemscope itemtype="https://schema.org/Organization">
              <link itemprop="url" href="https://www.iso.org/">
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.linkedin.com/company/isostandards" title="Linkedin"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://twitter.com/isostandards" title="Twitter"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.facebook.com/isostandards" title="Facebook"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.youtube.com/user/PlanetISO" title="YouTube"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.instagram.com/isostandards" title="Instagram"></a></li>
              <li><a itemprop="sameAs" target="_blank" rel="noopener" href="https://www.flickr.com/photos/isostandards" title="Flickr"></a></li>
            </ul>
          </div>
          <p class="lead">Great things happen when the world agrees</p>
          <div class="row">
            <div class="col-md-8 col-md-offset-2 pull-left">
              <p class="text-xs">We are committed to ensuring that our website is accessible to everyone. If you have any questions or suggestions regarding the accessibility of this site, please <a href="mailto:webmaster@iso.org?subject=Accessibility" style="white-space: nowrap">contact us</a>.</p>
              <p class="text-sm"><a href="#copyright" target="_self" data-toggle="collapse" aria-expanded="false" aria-controls="copyright">© All Rights Reserved</a> <span id="copyright" class="collapse">All ISO publications and materials are protected by copyright and are subject to the user’s acceptance of ISO’s conditions of copyright. Any use, including reproduction requires our written permission. All copyright requests should be addressed to <a href="mailto:copyright@iso.org">copyright@iso.org</a>.</span></p>
            </div>
          </div>
        </div>
        <div class="topbar">
          <div class="topbar-content">
            <a class="logo isologo logo-xs theme-red poweredby page-scroll logo-scrollTop" href="#page-top" title="Scroll to top"></a>
            <div class="isologo-print"><img src="https://cdn.iso.org/resources/wood/3.3.7/img/iso/iso-logo-print.gif" alt="ISO logo for print" /></div>
            <div class="poweredby-txt">Powered by</div>
          </div>
        </div>
        <div class="rubber"></div>
      </footer>

    </main>

    


  </body>
</html>
299
+ http_version:
300
+ recorded_at: Thu, 24 Feb 2022 13:51:41 GMT
301
+ recorded_with: VCR 5.0.0